protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var max = response.Aggs.Max("max_commits");
max.Should().NotBeNull();
max.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var commitsAvg = response.Aggs.Average("average_commits");
commitsAvg.Should().NotBeNull();
commitsAvg.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
/** === Handling Responses
* Using the `.Agg` aggregation helper we can fetch our aggregation results easily
* in the correct type. <<aggs-vs-aggregations, Be sure to read more about .Aggs vs .Aggregations>>
*/
response.IsValid.Should().BeTrue();
var filterAgg = response.Aggs.Filters("projects_by_state");
filterAgg.Should().NotBeNull();
var namedResult = filterAgg.NamedBucket("belly_up");
namedResult.Should().NotBeNull();
namedResult.DocCount.Should().BeGreaterThan(0);
namedResult = filterAgg.NamedBucket("stable");
namedResult.Should().NotBeNull();
namedResult.DocCount.Should().BeGreaterThan(0);
namedResult = filterAgg.NamedBucket("very_active");
namedResult.Should().NotBeNull();
namedResult.DocCount.Should().BeGreaterThan(0);
namedResult = filterAgg.NamedBucket("other_states_of_being");
namedResult.Should().NotBeNull();
namedResult.DocCount.Should().Be(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var projectCount = response.Aggs.Cardinality("state_count");
projectCount.Should().NotBeNull();
projectCount.Value.Should().Be(3);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var commitsSum = response.Aggs.Sum("commits_sum");
commitsSum.Should().NotBeNull();
commitsSum.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var sigNames = response.Aggs.SignificantTerms("significant_names");
sigNames.Should().NotBeNull();
sigNames.DocCount.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var min = response.Aggs.Max("min_commits");
min.Should().NotBeNull();
min.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var commitCount = response.Aggs.ValueCount("commit_count");
commitCount.Should().NotBeNull();
commitCount.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var sumTheHardWay = response.Aggs.ScriptedMetric("sum_the_hard_way");
sumTheHardWay.Should().NotBeNull();
sumTheHardWay.Value<int>().Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var min = response.Aggs.Min("min_last_activity");
min.Should().NotBeNull();
min.Value.Should().BeGreaterThan(0);
min.ValueAsString.Should().NotBeNullOrEmpty();
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var allProjects = response.Aggs.Global("all_projects");
allProjects.Should().NotBeNull();
var names = allProjects.Terms("names");
names.Should().NotBeNull();
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var commits = response.Aggs.Histogram("commits");
commits.Should().NotBeNull();
foreach (var item in commits.Items)
item.DocCount.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var ringsAroundAmsterdam = response.Aggs.GeoDistance("rings_around_amsterdam");
ringsAroundAmsterdam.Should().NotBeNull();
ringsAroundAmsterdam.Items.Where(r => r.Key == "*-100.0").FirstOrDefault().Should().NotBeNull();
ringsAroundAmsterdam.Items.Where(r => r.Key == "100.0-300.0").FirstOrDefault().Should().NotBeNull();
ringsAroundAmsterdam.Items.Where(r => r.Key == "300.0-*").FirstOrDefault().Should().NotBeNull();
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var commitsOutlier = response.Aggs.Percentiles("commits_outlier");
commitsOutlier.Should().NotBeNull();
commitsOutlier.Items.Should().NotBeNullOrEmpty();
foreach (var item in commitsOutlier.Items)
item.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var commitsOutlier = response.Aggs.PercentileRanks("commits_outlier");
commitsOutlier.Should().NotBeNull();
commitsOutlier.Items.Should().NotBeNullOrEmpty();
foreach (var item in commitsOutlier.Items)
item.Should().NotBeNull();
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var commitsAvg = response.Aggs.Average("average_commits");
commitsAvg.Should().NotBeNull();
commitsAvg.Value.Should().BeGreaterThan(0);
commitsAvg.Meta.Should().NotBeNull().And.HaveCount(1);
commitsAvg.Meta["foo"].Should().Be("bar");
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var sample = response.Aggs.Sampler("sample");
sample.Should().NotBeNull();
var sigTags = sample.SignificantTerms("significant_names");
sigTags.Should().NotBeNull();
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeFalse();
var serverError = response.ServerError;
serverError.Should().NotBeNull();
serverError.Status.Should().Be(400);
serverError.Error.Reason.Should().Be("all shards failed");
serverError.Error.RootCause.First().Reason.Should().Contain("[-1m]");
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.ShouldBeValid();
var matrix = response.Aggs.MatrixStats("matrixstats");
matrix.Should().NotBeNull();
matrix.Fields.Should().NotBeNull().And.HaveCount(2);
AssertField(matrix, "numberOfCommits");
AssertField(matrix, "numberOfContributors");
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var commitRanges = response.Aggs.Range("commit_ranges");
commitRanges.Should().NotBeNull();
commitRanges.Buckets.Count.Should().Be(3);
commitRanges.Buckets.Where(r => r.Key == "*-100.0").FirstOrDefault().Should().NotBeNull();
commitRanges.Buckets.Where(r => r.Key == "100.0-500.0").FirstOrDefault().Should().NotBeNull();
commitRanges.Buckets.Where(r => r.Key == "500.0-*").FirstOrDefault().Should().NotBeNull();
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var ipRanges = response.Aggs.IpRange("ip_ranges");
ipRanges.Should().NotBeNull();
ipRanges.Buckets.Should().NotBeNull();
ipRanges.Buckets.Count.Should().BeGreaterThan(0);
foreach (var range in ipRanges.Buckets)
range.DocCount.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var centroid = response.Aggs.GeoCentroid("centroid");
centroid.Should().NotBeNull();
centroid.Location.Should().NotBeNull();
centroid.Location.Latitude.Should().NotBe(0);
centroid.Location.Longitude.Should().NotBe(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var states = response.Aggs.Terms("states");
states.Should().NotBeNull();
foreach (var item in states.Items)
{
item.Key.Should().NotBeNullOrEmpty();
item.DocCount.Should().BeGreaterOrEqualTo(1);
}
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var commitStats = response.Aggs.Stats("commit_stats");
commitStats.Should().NotBeNull();
commitStats.Average.Should().BeGreaterThan(0);
commitStats.Max.Should().BeGreaterThan(0);
commitStats.Min.Should().BeGreaterThan(0);
commitStats.Count.Should().BeGreaterThan(0);
commitStats.Sum.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
foreach (var document in response.Documents)
{
document.Name.Should().NotBeNull();
document.StartedOn.Should().NotBe(default(DateTime));
document.Description.Should().BeNull();
}
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeFalse();
response.ServerError.Should().NotBeNull();
response.ServerError.Status.Should().Be(400);
response.ServerError.Error.Should().NotBeNull();
var rootCauses = response.ServerError.Error.RootCause;
rootCauses.Should().NotBeNullOrEmpty();
var rootCause = rootCauses.First();
rootCause.Type.Should().Be("parsing_exception");
}
protected void TestDefaultAssertions(ISearchResponse<ElasticsearchProject> queryResponse)
{
Assert.True(queryResponse.IsValid, "response is not valid");
Assert.NotNull(queryResponse.ConnectionStatus, "connection status is null");
Assert.Null(queryResponse.ConnectionStatus.OriginalException, "exception should not be set");
Assert.True(queryResponse.Total > 0, "Query yielded no results as indicated by total returned from ES");
Assert.True(queryResponse.Documents.Any(), "documents.any() is false");
Assert.True(queryResponse.Documents.Count() > 0, "documents.count is 0");
Assert.True(queryResponse.Shards.Total > 0, "did not hit any shard");
Assert.True(queryResponse.Shards.Successful == queryResponse.Shards.Total, "Not all the shards were hit succesfully");
Assert.True(queryResponse.Shards.Failed == 0, "shards failed is not null");
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var projectsPerMonth = response.Aggs.DateHistogram("projects_started_per_month");
projectsPerMonth.Should().NotBeNull();
projectsPerMonth.Buckets.Should().NotBeNull();
projectsPerMonth.Buckets.Count.Should().BeGreaterThan(0);
var averageCommits = response.Aggs.AverageBucket("average_commits_per_month");
averageCommits.Should().NotBeNull();
averageCommits.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var projectsPerMonth = response.Aggs.DateHistogram("projects_started_per_month");
projectsPerMonth.Should().NotBeNull();
projectsPerMonth.Items.Should().NotBeNull();
projectsPerMonth.Items.Count.Should().BeGreaterThan(0);
var commitsSum = response.Aggs.SumBucket("sum_of_commits");
commitsSum.Should().NotBeNull();
commitsSum.Value.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse<Project> response)
{
response.IsValid.Should().BeTrue();
var tags = response.Aggs.Nested("tags");
tags.Should().NotBeNull();
var tagNames = tags.Terms("tag_names");
tagNames.Should().NotBeNull();
foreach(var item in tagNames.Buckets)
{
item.Key.Should().NotBeNullOrEmpty();
item.DocCount.Should().BeGreaterThan(0);
}
}
private static Dictionary <int, long?> BuildLevelAggregationResult(ISearchResponse <ApprenticeshipSearchResultsDocument> results)
{
var levelAggregation = new Dictionary <int, long?>();
if (results.Aggregations.Terms(LevelAggregateName) != null)
{
foreach (var item in results.Aggregations.Terms(LevelAggregateName).Buckets)
{
int iKey;
if (int.TryParse(item.Key, out iKey))
{
levelAggregation.Add(iKey, item.DocCount);
}
}
}
return(levelAggregation);
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
/** === Handling Responses
* The `AggregateDictionary found on `.Aggregations` on `ISearchResponse<T>` has several helper methods
* so we can fetch our aggregation results easily in the correct type.
* <<handling-aggregate-response, Be sure to read more about these helper methods>>
*/
response.ShouldBeValid();
var filterAgg = response.Aggregations.Filter("bethels_projects");
filterAgg.Should().NotBeNull();
filterAgg.DocCount.Should().BeGreaterThan(0);
var tags = filterAgg.Terms("project_tags");
tags.Should().NotBeNull();
tags.Buckets.Should().NotBeEmpty();
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.ShouldBeValid();
var projectsPerMonth = response.Aggregations.DateHistogram("projects_started_per_month");
projectsPerMonth.Should().NotBeNull();
projectsPerMonth.Buckets.Should().NotBeNull();
projectsPerMonth.Buckets.Count.Should().BeGreaterThan(0);
// percentiles not calculated for the first bucket
foreach (var item in projectsPerMonth.Buckets.Skip(1))
{
var movingPercentiles = item.MovingPercentiles("moving_percentiles");
movingPercentiles.Should().NotBeNull();
movingPercentiles.Items.Should().NotBeNull();
}
}
public static ISearchResponse <TResult> Search <T, TResult>(IElasticClient elasticClient, Func <SearchDescriptor <T>, SearchDescriptor <T> > searchSelector)
where T : class
where TResult : class
{
ISearchResponse <TResult> response = null;
var stopwatch = Stopwatch.StartNew();
// on n'a pas forcément de serveur Elasticsearch, alors on commente l'appel (#ES_BYPASS)
//response = elasticClient.Search<T, TResult>(searchSelector);
// on simule l'attente de l'appel au serveur Elasticsearch
Thread.Sleep(new Random().Next(10, 50));
Console.WriteLine($"[Search<T, TResult>(Func<...>) ] Duration: {stopwatch.ElapsedMilliseconds}ms");
return(response);
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
/** ==== Handling responses
* The `AggregateDictionary found on `.Aggregations` on `SearchResponse<T>` has several helper methods
* so we can fetch our aggregation results easily in the correct type.
* <<handling-aggregate-response, Be sure to read more about these helper methods>>
*/
response.ShouldBeValid();
var dateHistogram = response.Aggregations.AutoDateHistogram("projects_started_per_month");
dateHistogram.Should().NotBeNull();
dateHistogram.Interval.Should().NotBeNull();
dateHistogram.Buckets.Should().NotBeNull();
dateHistogram.Buckets.Count.Should().BeGreaterThan(1);
foreach (var item in dateHistogram.Buckets)
{
item.Date.Should().NotBe(default);
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.ShouldBeValid();
var states = response.Aggregations.Terms <StateOfBeing>("states");
states.Should().NotBeNull();
states.DocCountErrorUpperBound.Should().HaveValue();
states.SumOtherDocCount.Should().HaveValue();
states.Buckets.Should().NotBeNull();
states.Buckets.Count.Should().BeGreaterThan(0);
foreach (var item in states.Buckets)
{
item.Key.Should().BeOfType <StateOfBeing>();
item.DocCount.Should().BeGreaterOrEqualTo(1);
}
states.Meta.Should().NotBeNull().And.HaveCount(1);
states.Meta["foo"].Should().Be("bar");
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.IsValid.Should().BeTrue();
var projectsPerMonth = response.Aggs.DateHistogram("projects_started_per_month");
projectsPerMonth.Should().NotBeNull();
projectsPerMonth.Items.Should().NotBeNull();
projectsPerMonth.Items.Count.Should().BeGreaterThan(0);
// derivative not calculated for the first bucket
foreach (var item in projectsPerMonth.Items.Skip(1))
{
var commitsDerivative = item.Derivative("commits_derivative");
commitsDerivative.Should().NotBeNull();
commitsDerivative.Value.Should().NotBe(null);
}
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.ShouldBeValid();
var projectsPerMonth = response.Aggregations.DateHistogram("projects_started_per_month");
projectsPerMonth.Should().NotBeNull();
projectsPerMonth.Buckets.Should().NotBeNull();
projectsPerMonth.Buckets.Count.Should().BeGreaterThan(0);
// average not calculated for the first bucket
foreach (var item in projectsPerMonth.Buckets.Skip(1))
{
var movingAvg = item.MovingAverage("commits_moving_avg");
movingAvg.Should().NotBeNull();
movingAvg.Value.Should().BeGreaterThan(0);
}
}
public ActionResult QuickSearch(string[] options, string searchparam, int page = 1)
{
ISearchResponse <Doc> searchResponse = null;
if (options.FirstOrDefault() == "match")
{
searchResponse = ESQueryService.Match(searchparam, page);
}
else
{
searchResponse = ESQueryService.MatchPhrase(searchparam, page);
}
ViewBag.Match = options.FirstOrDefault();
ViewBag.Page = page;
ViewBag.SearchParam = searchparam;
return(View(searchResponse));
}
/// <summary>
/// Search for Terms based on the search criteria.
/// </summary>
/// <param name="dictionary">The value for dictionary.</param>
/// <param name="audience">Patient or Healthcare provider</param>
/// <param name="language">The language in which the details needs to be fetched</param>
/// <param name="searchText">The text to search for.</param>
/// <param name="matchType">Set to true to allow search to find terms which contain the query string instead of explicitly starting with it.</param>
/// <param name="size">The number of records to retrieve.</param>
/// <returns>An array of Suggestion objects</returns>
public async Task <Suggestion[]> GetSuggestions(string dictionary, AudienceType audience, string language, string searchText, MatchType matchType, int size)
{
// Set up the SearchRequest to send to elasticsearch.
Indices index = Indices.Index(new string[] { this._apiOptions.AliasName });
Types types = Types.Type(new string[] { "terms" });
ISearchResponse <Suggestion> response = null;
try
{
SearchRequest request;
switch (matchType)
{
default:
case MatchType.Begins:
case MatchType.Exact:
request = BuildNonContainsRequest(index, types, dictionary, language, audience, searchText, matchType, size);
break;
case MatchType.Contains:
request = BuildContainsRequest(index, types, dictionary, language, audience, searchText, size);
break;
}
response = await _elasticClient.SearchAsync <Suggestion>(request);
}
catch (Exception ex)
{
string msg = $"Could not search dictionary '{dictionary}', audience '{audience}', and language '{language}'.";
_logger.LogError($"Error searching index: '{this._apiOptions.AliasName}'.");
_logger.LogError(ex, msg);
throw new APIErrorException(500, msg);
}
if (!response.IsValid)
{
_logger.LogError($"Invalid response when searching for dictionary '{dictionary}', audience '{audience}', language '{language}', query '{searchText}', contains '{matchType}', size '{size}'.");
throw new APIErrorException(500, "errors occured");
}
List <Suggestion> retVal = new List <Suggestion>(response.Documents);
return(retVal.ToArray());
}
private ISearchDocumentDTO GetSearchDocumentDTO(ISearchResponse <dynamic> response)
{
ISearchDocumentDTO searchDocument = new SearchDocumentDTO();
searchDocument.Results = new List <ISearchResultDocumentDTO>();
searchDocument.Count = response.Total;
if (response != null && response.Hits != null)
{
foreach (var hit in response.Hits)
{
ISearchResultDocumentDTO result = new SearchResultDocumentDTO();
result.Score = hit.Score;
switch (hit.Type)
{
case "article":
ArticleAdo article = hit.Source;
Map_ArticleAdo_To_SearchResultDocumentDTO(article, result);
break;
case "research-topic":
Journal.Public.DataAccess.ElasticSearch.ADO.ResearchTopic.ResearchTopicAdo researchTopic = hit.Source;
Map_ResearchTopicAdo_To_SearchResultDocumentDTO(researchTopic, result);
break;
case "editorial-board-user":
EditorialBoardUserAdo editorialBoard = hit.Source;
Map_EditorialBoardUserAdo_To_SearchResultDocumentDTO(editorialBoard, result);
break;
case "journal":
Journal.Public.DataAccess.ElasticSearch.ADO.Journal.JournalAdo journal = hit.Source;
Map_JournalAdo_To_SearchResultDocumentDTO(journal, result);
break;
}
searchDocument.Results.Add(result);
}
}
return(searchDocument);
}
private static List <Aggs> ExtractPipeAggs(ISearchResponse <T> r)
{
var aggss = new List <Aggs>();
foreach (var ag in r.Aggregations)
{
var segs = ag.Key.Split('_');
switch (segs[0])
{
case "area":
var areas = r.Aggs.Terms("area");
var areaAggs = new Aggs("area");
foreach (var b in areas.Buckets)
{
if (b.Aggregations.Count > 0)
{
var agg = new Agg();
agg.count = b.DocCount ?? 0;
agg.value = Math.Round(b.Average(segs[1] /*"ave_sal"*/).Value ?? 0, 2);
areaAggs.aggs.Add(agg);
}
}
aggss.Add(areaAggs);
break;
case "mon":
var mons = r.Aggs.DateHistogram("mon");
var monAggs = new Aggs("mon");
foreach (var b in mons.Buckets)
{
if (b.Aggregations.Count > 0)
{
var agg = new Agg();
agg.count = b.DocCount ?? 0;
agg.value = Math.Round(b.Average(/*"ave_sal"*/ segs[1]).Value ?? 0, 2);
monAggs.aggs.Add(agg);
}
}
aggss.Add(monAggs);
break;
}
}
return(aggss);
}
public IBulkResponse IndexSearchResults(ISearchResponse <T> searchResult, IObserver <IReindexResponse <T> > observer, IndexName toIndex, int page)
{
if (!searchResult.IsValid)
{
throw Throw($"Indexing failed on scroll #{page}.", searchResult.ApiCall);
}
var hits = searchResult.Hits.ToList();
var bulkOperations = new List <IBulkOperation>(hits.Count);
foreach (var h in hits)
{
var item = new BulkIndexOperation <T>(h.Source)
{
Type = h.Type,
Index = toIndex,
Id = h.Id,
Routing = h.Routing,
Timestamp = h.Timestamp
};
if (h.Parent != null)
{
item.Parent = h.Parent;
}
if (h.Ttl.HasValue)
{
item.Ttl = h.Ttl;
}
this.Alter?.Invoke(h, h.Source, item);
bulkOperations.Add(item);
}
var indexResult = this._client.Bulk(new BulkRequest {
Operations = bulkOperations
});
if (!indexResult.IsValid)
{
throw Throw($"Failed indexing page {page}.", indexResult.ApiCall);
}
return(indexResult);
}
public void SimpleTermFacet()
{
ISearchResponse <ElasticsearchProject> queryResults = this.SearchRaw <ElasticsearchProject>(
@" { ""query"" : {
""match_all"" : { }
},
""facets"" : {
""followers.lastName"" : { ""terms"" : {""field"" : ""followers.lastName""} }
}
}"
);
var facet = queryResults.Facets["followers.lastName"];
this.TestDefaultAssertions(queryResults);
Assert.IsInstanceOf <TermFacet>(facet);
var tf = (TermFacet)facet;
Assert.AreEqual(0, tf.Missing);
Assert.Greater(tf.Other, 0);
Assert.Greater(tf.Total, 0);
Assert.Greater(tf.Items.Count(), 0);
foreach (TermItem term in tf.Items)
{
Assert.Greater(term.Count, 0);
Assert.IsNotNullOrEmpty(term.Term);
}
tf = queryResults.Facet <TermFacet>(p => p.Followers.Select(f => f.LastName));
Assert.AreEqual(0, tf.Missing);
Assert.Greater(tf.Other, 0);
Assert.Greater(tf.Total, 0);
Assert.Greater(tf.Items.Count(), 0);
var items = queryResults.FacetItems <TermItem>(p => p.Followers.Select(f => f.LastName));
foreach (var i in items)
{
Assert.Greater(i.Count, 0);
Assert.IsNotNullOrEmpty(i.Term);
}
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.IsValid.Should().BeTrue();
/**
* Using the `.Agg` aggregation helper we can fetch our aggregation results easily
* in the correct type. [Be sure to read more about `.Agg` vs `.Aggregations` on the response here]()
*/
var dateHistogram = response.Aggs.DateHistogram("projects_started_per_month");
dateHistogram.Should().NotBeNull();
dateHistogram.Items.Should().NotBeNull();
dateHistogram.Items.Count.Should().BeGreaterThan(10);
foreach (var item in dateHistogram.Items)
{
item.Date.Should().NotBe(default(DateTime));
item.DocCount.Should().BeGreaterThan(0);
}
}
public TextResourceContract ProcessSearchPageByCriteria(ISearchResponse <TextResourceContract> response)
{
if (!response.IsValid)
{
throw new FulltextDatabaseException(response.DebugInformation);
}
foreach (var hit in response.Hits)
{
foreach (var value in hit.Highlights.Values)
{
foreach (var highlight in value.Highlights)
{
hit.Source.PageText = highlight;
return(hit.Source);
}
}
}
return(null);
}
#pragma warning restore 618, 612
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.ShouldBeValid();
var projectsPerMonth = response.Aggregations.DateHistogram("projects_started_per_month");
projectsPerMonth.Should().NotBeNull();
projectsPerMonth.Buckets.Should().NotBeNull();
projectsPerMonth.Buckets.Count.Should().BeGreaterThan(0);
var commitsStats = response.Aggregations.StatsBucket("stats_commits_per_month");
commitsStats.Should().NotBeNull();
commitsStats.Average.Should().BeGreaterThan(0);
commitsStats.Max.Should().BeGreaterThan(0);
commitsStats.Min.Should().BeGreaterThan(0);
commitsStats.Count.Should().BeGreaterThan(0);
commitsStats.Sum.Should().BeGreaterThan(0);
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.ShouldBeValid();
var projectsPerMonth = response.Aggs.DateHistogram("projects_started_per_month");
projectsPerMonth.Should().NotBeNull();
projectsPerMonth.Buckets.Should().NotBeNull();
projectsPerMonth.Buckets.Count.Should().BeGreaterThan(0);
var commitsOutlier = response.Aggs.PercentilesBucket("commits_outlier");
commitsOutlier.Should().NotBeNull();
commitsOutlier.Items.Should().NotBeNullOrEmpty();
foreach (var item in commitsOutlier.Items)
{
item.Value.Should().BeGreaterThan(0);
}
}
public DataSet Search(string searchText, IIdentity identity)
{
ISearchResponse <object> response =
_client.Search <object>(s => s.Types("bug")
.Query(q => q.QueryString(d => d.Query(searchText)))
.Take(500) //Maximum of 500 results just to avoid major performance problems
.Highlight(h => h.PreTags("<span class='highlighted'>")
.PostTags("</span>")
.OnFields(f => f.OnField("*"))));
DataSet results = GetSearchResultDataSet();
DataTable resultTable = results.Tables[0];
var filteredHits = GetHitsFilteredBySecurity(response, identity);
foreach (var hit in filteredHits)
{
DataRow resultRow = resultTable.NewRow();
JObject bug = (JObject)hit.Source;
int bugId = Convert.ToInt32(bug["bg_id"]);
resultRow[ResultColumns.Color] = "#ffffff";
resultRow[ResultColumns.Id] = bugId;
resultRow[ResultColumns.Description] = bug["desc"].ToString();
if (hit.Highlights.Any())
{
var highlight = hit.Highlights.First();
resultRow[ResultColumns.Source] = highlight.Value.Field;
resultRow[ResultColumns.Text] = highlight.Value.Highlights.FirstOrDefault();
}
resultRow[ResultColumns.Date] = bug["bg_reported_date"].ToString();
resultRow[ResultColumns.Status] = bug["status"].ToString();
resultRow[ResultColumns.Score] = Convert.ToDecimal(hit.Score);
resultTable.Rows.Add(resultRow);
}
return(results);
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.IsValid.Should().BeTrue();
/**
* Using the `.Agg` aggregation helper we can fetch our aggregation results easily
* in the correct type. [Be sure to read more about `.Agg` vs `.Aggregations` on the response here]()
*/
var filterAgg = response.Aggs.Filters("projects_by_state");
filterAgg.Should().NotBeNull();
var results = filterAgg.AnonymousBuckets();
results.Count.Should().Be(3);
foreach (var singleBucket in results)
{
singleBucket.DocCount.Should().BeGreaterThan(0);
}
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.ShouldBeValid();
var composite = response.Aggregations.Composite("my_buckets");
composite.Should().NotBeNull();
composite.Buckets.Should().NotBeNullOrEmpty();
composite.AfterKey.Should().NotBeNull();
composite.AfterKey.Should().HaveCount(1).And.ContainKeys("started");
foreach (var item in composite.Buckets)
{
var key = item.Key;
key.Should().NotBeNull();
key.TryGetValue("started", out string startedString).Should().BeTrue();
startedString.Should().NotBeNullOrWhiteSpace();
}
}
public ListResult <sdk.Account> Find(int skip, int take, string keyword = "", string order_by = "", bool descending = false)
{
return(base.ExecuteFunction("Find", delegate()
{
int takePlus = take;
if (take != int.MaxValue)
{
takePlus++; // for stepping
}
QueryContainer query = Query <sdk.Account>
.MultiMatch(m => m
.Query(keyword)
.Type(TextQueryType.PhrasePrefix)
.Fields(mf => mf
.Field(f => f.email)
));
SortOrder sortOrder = SortOrder.Ascending;
if (descending)
{
sortOrder = SortOrder.Descending;
}
if (string.IsNullOrEmpty(order_by))
{
order_by = "";
}
ElasticClient client = this.ClientFactory.CreateClient();
ISearchResponse <sdk.Account> searchResponse = client.Search <sdk.Account>(s => s
.Query(q => query)
.Skip(skip)
.Take(takePlus)
.Sort(r => r.Field(order_by, sortOrder))
.Type(this.DocumentType));
ListResult <sdk.Account> result = searchResponse.Documents.ToSteppedListResult(skip, take, searchResponse.GetTotalHit());
return result;
}));
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
response.Total.Should().BeGreaterThan(0);
response.Hits.Count.Should().BeGreaterThan(0);
response.HitsMetadata.Total.Value.Should().Be(response.Total);
response.HitsMetadata.Total.Relation.Should().Be(TotalHitsRelation.EqualTo);
response.Hits.First().Should().NotBeNull();
response.Hits.First().Source.Should().NotBeNull();
response.Aggregations.Count.Should().BeGreaterThan(0);
response.Took.Should().BeGreaterThan(0);
var startDates = response.Aggregations.Terms("startDates");
startDates.Should().NotBeNull();
foreach (var document in response.Documents)
{
document.ShouldAdhereToSourceSerializerWhenSet();
}
}
public static Resp_Brands Brand_Query_Handle(ISearchResponse <OrgCompanyBrand> response, int pg_size)
{
var documents = response.Documents; //
var hits = response.Hits;
foreach (var hit in hits)
{
var hl = hit.Highlights;
foreach (var pair in hl)
{
if (pair.Key == "ob_name")
{
var content = pair.Value.Highlights.FirstOrDefault();
var doc = documents.FirstOrDefault(d => d.ob_name == hit.Source.ob_name);
if (!string.IsNullOrEmpty(content))
{
doc.ob_name = content;
}
}
}
}
var list = documents /*.Take(pg_size)*/.Select(d => d.To_Brand_Abs()).ToList();
var dict = new Dictionary <string, long>();
//dict.Add("0", 0);
if (response.Aggregations.ContainsKey("term_class"))
{
var agg = (BucketAggregate)response.Aggregations["term_class"];
foreach (var i in agg.Items)
{
var pair = (KeyedBucket)i;
dict.Add(pair.Key, pair.DocCount ?? 0);
}
}
return(new Resp_Brands()
{
brand_list = list, class_agg = dict, count = response.Total
});
}
private static void ExtractFilter(Q.Query <Displayable> query, ISearchResponse <ElasticTitleIndex> results)
{
query.Filters = new ConcurrentDictionary <string, List <FacetFilter> >();
lock (query.Filters)
{
if (query.ScopeId > 0)
{
query.Filters.TryAdd(SearchConstants.Ownership,
GetOwnershipFacetFilter(results.Aggregations[SearchConstants.Ownership] as SingleBucketAggregate,
query.Facets));
}
query.Filters.TryAdd(SearchConstants.ListPrice,
GetListPriceFacetFilter(results.Aggregations[SearchConstants.ListPrice] as SingleBucketAggregate, query.Facets,
SearchConstants.MediaType));
query.Filters.TryAdd(SearchConstants.MediaType,
GetFacetFilter(results.Aggregations[SearchConstants.MediaType] as SingleBucketAggregate, query.Facets,
SearchConstants.MediaType));
query.Filters.TryAdd(SearchConstants.Genre,
GetFacetFilter(results.Aggregations[SearchConstants.Genre] as SingleBucketAggregate, query.Facets,
SearchConstants.Genre));
query.Filters.TryAdd(SearchConstants.Audience,
GetFacetFilter(results.Aggregations[SearchConstants.Audience] as SingleBucketAggregate, query.Facets,
SearchConstants.Audience));
query.Filters.TryAdd(SearchConstants.Language,
GetFacetFilter(results.Aggregations[SearchConstants.Language] as SingleBucketAggregate, query.Facets,
SearchConstants.Language));
query.Filters.TryAdd(SearchConstants.UsageTerm,
GetFacetFilter(results.Aggregations[SearchConstants.UsageTerm] as SingleBucketAggregate, query.Facets,
SearchConstants.UsageTerm));
query.Filters.TryAdd(SearchConstants.Facets.ContentAdvisorySex,
GetFacetFilter(results.Aggregations[SearchConstants.ContentAdvisory] as SingleBucketAggregate,
query.Facets,
"sex"));
query.Filters.TryAdd(SearchConstants.Facets.ContentAdvisoryLanguage,
GetFacetFilter(results.Aggregations[SearchConstants.ContentAdvisory] as SingleBucketAggregate,
query.Facets,
"language"));
query.Filters.TryAdd(SearchConstants.Facets.ContentAdvisoryViolence,
GetFacetFilter(results.Aggregations[SearchConstants.ContentAdvisory] as SingleBucketAggregate,
query.Facets,
"violence"));
}
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
var myCompletionSuggest = response.Suggest["my-completion-suggest"];
myCompletionSuggest.Should().NotBeNull();
var suggest = myCompletionSuggest.First();
suggest.Text.Should().Be(Project.Instance.Name);
suggest.Length.Should().BeGreaterThan(0);
var option = suggest.Options.First();
option.Text.Should().NotBeNullOrEmpty();
option.Score.Should().BeGreaterThan(0);
var payload = option.Payload <ProjectPayload>();
payload.Should().NotBeNull();
payload.Name.Should().Be(Project.Instance.Name);
payload.State.Should().NotBeNull();
}
public ActionResult GetHurricanes(string hurricaneNames)
{
var client = new ElasticClient();
string indexName = "linestring1";
var settings = new ConnectionSettings(new Uri("http://ec2-54-218-10-53.us-west-2.compute.amazonaws.com:9200")).DefaultIndex(indexName);
client = new ElasticClient(settings);
List <string> names = hurricaneNames.Split(',').ToList <string>();
ISearchResponse <LineStringModel> searchResponse = client.Search <LineStringModel>(s => s.Size(2000)
.Query(q => q
.MatchAll()
));
/*BucketAggregate bucket = (BucketAggregate)searchResponse.Aggregations["hurricanes"];
*
* KeyedBucket<LineStringModel> keyedB = (KeyedBucket<LineStringModel>)bucket.Items;
* List<LineStringModel> documents = new List<LineStringModel>();
*
* List<LineStringModel> filteredList = new List<LineStringModel>();
*
* foreach (LineStringModel model in documents)
* {
* if (names.Contains(model.name))
* {
* filteredList.Add(model);
* }
*
* }*/
//List<LineStringModel> filteredList = searchResponse.Documents.ToList<LineStringModel>().Where(s => s.name == names[0].ToString()).ToList<LineStringModel>();
//var allowedStatus = new[] { "A", "B", "C" };
List <LineStringModel> filteredList = searchResponse.Documents.ToList <LineStringModel>().Where(o => names.Contains(o.name)).ToList <LineStringModel>();
JsonResult result = Json(filteredList, JsonRequestBehavior.AllowGet);
return(result);
}
public ElasticSearchResponse <T> Search <T>(AbstractSearchQuery <T> query) where T : class
{
SearchDescriptor <T> searchQuery = query.Build();
int retryCount = 0;
Exception lastException = null;
while (retryCount < MaxRetry)
{
try
{
ISearchResponse <T> searchResponse = _client.Search <T>(searchQuery);
if (!searchResponse.IsValid)
{
throw new ElasticSearchServerException(searchResponse.ServerError.Error);
}
ElasticSearchResponse <T> response = new ElasticSearchResponse <T>
{
Count = searchResponse.Documents.Count(),
TotalCount = searchResponse.Total,
MaxScore = searchResponse.MaxScore,
Results = searchResponse.Documents
};
return(response);
}
catch (WebException wex)
{
lastException = wex;
}
catch (Exception ex)
{
lastException = ex;
}
retryCount++;
Thread.Sleep(500);
}
throw new ElasticSearchException("There was an error occured while performing a search", lastException);
}
private static void ProcessResponse(string data, ISearchResponse <LogItem> searchResults)
{
Console.WriteLine("===== Search results {0} =====", data);
Console.WriteLine("Request: {0}", System.Text.Encoding.UTF8.GetString(searchResults.ConnectionStatus.Request));
// Console.WriteLine("Response: {0}", searchResults.ConnectionStatus.ResponseRaw.ToString());
if (!searchResults.IsValid)
{
Console.WriteLine("Invalid response!!!");
return;
}
if (searchResults.Documents.Any())
{
Console.WriteLine("We have docs: {0}", searchResults.Documents.Count());
foreach (var item in searchResults.Documents)
{
Console.WriteLine(" {0}", item);
}
}
if (searchResults.Facets.Any())
{
Console.WriteLine("We have facets: {0}", searchResults.Facets.Count());
foreach (var item in searchResults.Facets)
{
Console.WriteLine(" {0}", item);
}
}
if (searchResults.Hits.Any())
{
Console.WriteLine("We have hits: {0}", searchResults.Hits.Count());
foreach (var item in searchResults.Hits)
{
Console.WriteLine(" Id:{0} Index:{1}", item.Id, item.Index);
}
}
if (searchResults.Shards.Total != 0)
{
Console.WriteLine("Total Shards: {0}", searchResults.Shards.Total);
Console.WriteLine("Total Successful: {0}", searchResults.Shards.Successful);
Console.WriteLine("Total Failed: {0}", searchResults.Shards.Failed);
Console.WriteLine("Total Failures: {0}", searchResults.Shards.Failures);
}
}
protected override void ExpectResponse(ISearchResponse <Project> response)
{
/** === Handling Responses
* Using the `.Agg` aggregation helper we can fetch our aggregation results easily
* in the correct type. <<aggs-vs-aggregations, Be sure to read more about .Aggs vs .Aggregations>>
*/
response.ShouldBeValid();
var dateHistogram = response.Aggs.DateRange("projects_date_ranges");
dateHistogram.Should().NotBeNull();
dateHistogram.Buckets.Should().NotBeNull();
/** We specified three ranges so we expect to have three of them in the response */
dateHistogram.Buckets.Count.Should().Be(3);
foreach (var item in dateHistogram.Buckets)
{
item.DocCount.Should().BeGreaterThan(0);
}
}
