private async Task <List <ViewProject> > PopulateProjectStatsAsync(List <ViewProject> viewProjects)
{
if (viewProjects.Count <= 0)
{
return(viewProjects);
}
var organizations = await _organizationRepository.GetByIdsAsync(viewProjects.Select(p => p.OrganizationId).ToArray(), true);
var projects = viewProjects.Select(p => new Project {
Id = p.Id, CreatedUtc = p.CreatedUtc, OrganizationId = p.OrganizationId
}).ToList();
var sf = new ExceptionlessSystemFilterQuery(projects, organizations);
var systemFilter = new ElasticQuery().WithSystemFilter(sf).WithDateRange(organizations.GetRetentionUtcCutoff(), SystemClock.UtcNow, (PersistentEvent e) => e.Date).WithIndexes(organizations.GetRetentionUtcCutoff(), SystemClock.UtcNow);
var result = await _eventRepository.CountBySearchAsync(systemFilter, null, $"terms:(project_id~{viewProjects.Count} cardinality:stack_id)");
foreach (var project in viewProjects)
{
var term = result.Aggregations.Terms <string>("terms_project_id")?.Buckets.FirstOrDefault(t => t.Key == project.Id);
project.EventCount = term?.Total ?? 0;
project.StackCount = (long)(term?.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0);
}
return(viewProjects);
}
public void Snippets_Muessen_Ve_Titel_Beinhaltet_Wenn_Titel_Snippet_Leer_Ist()
{
// arrange
var elasticSettings = new Mock <IElasticSettings>();
var userAccess = new UserAccess("123", AccessRoles.RoleOe1, null, null, false);
var query = new ElasticQuery();
var mockResponse = new
{
took = 1,
timed_out = false,
_shards = new
{
total = 2,
successful = 2,
failed = 0
},
hits = new
{
total = new { value = 1 },
max_score = 1.0,
hits = new[]
{
new
{
_index = "project",
_type = "project",
_id = "Project",
_score = 1.0,
_source = new TreeRecord
{
ArchiveRecordId = "1",
PrimaryDataFulltextAccessTokens = new List <string> {
AccessRoles.RoleBAR
},
Title = "Ve Title"
},
highlight = new
{
all_Metadata_Text = new[] { "<em>Fundstelle</em>", "Dies ist eine andere <em>Fundstelle</em>" },
all_Primarydata = new[] { "<em>Fundstelle</em> in den Primärdaten" }
}
}
}
}
};
var clientProvider = CreateClientProvider(mockResponse);
var service = new ElasticService(clientProvider, elasticSettings.Object);
// act
var result = service.RunQuery <TreeRecord>(query, userAccess);
// assert
result.Data.Items[0].Highlight["title"]
.Values <string>().First().Should()
.Be("Ve Title");
}
public void ConstructorWithNoExpressionDefaultsExpressionPropertyToConstantOfQuery()
{
var query = new ElasticQuery <Sample>(provider);
Assert.IsType <ConstantExpression>(query.Expression);
Assert.Same(query, (((ConstantExpression)query.Expression)).Value);
}
private async Task UpdateFilterStartDateRangesAsync(ElasticQuery filter, DateTime utcEnd)
{
// TODO: Cache this to save an extra search request when a date range isn't filtered.
var descriptor = new SearchDescriptor <PersistentEvent>()
.IgnoreUnavailable()
.Indices(_configuration.Events.Event.GetIndexesByQuery(filter))
.Type(_configuration.Events.Event.Name)
.SortAscending(ev => ev.Date)
.Take(1);
_configuration.Events.Event.QueryBuilder.ConfigureSearch(filter, GetQueryOptions(), descriptor);
var response = await _configuration.Client.SearchAsync <PersistentEvent>(descriptor).AnyContext();
_logger.Trace(() => response.GetRequest());
if (!response.IsValid)
{
string message = $"Error getting updated start date: {response.GetErrorMessage()}";
_logger.Error().Exception(response.ConnectionStatus.OriginalException).Message(message).Property("request", response.GetRequest()).Write();
throw new ApplicationException(message, response.ConnectionStatus.OriginalException);
}
var firstEvent = response.Hits.FirstOrDefault()?.Source;
if (firstEvent != null)
{
filter.DateRanges.Clear();
filter.WithDateRange(firstEvent.Date.UtcDateTime, utcEnd, EventIndexType.Fields.Date);
filter.Indexes.Clear();
filter.WithIndexes(firstEvent.Date.UtcDateTime, utcEnd);
}
}
public ISearchResult SearchByReferenceCodeWithoutSecurity <T>(string signatur)
where T : TreeRecord
{
Log.Debug($"CheckIsValidSignatur: Signatur:={signatur}");
var searchSignatur = signatur;
if (signatur.Contains("\""))
{
searchSignatur = signatur.Replace("\"", string.Empty);
}
var elasticQuery = new ElasticQuery();
var query = ElasticQueryBuilder.CreateQueryForSignatur(searchSignatur);
elasticQuery.Query = query;
var found = elasticService.RunQueryWithoutSecurityFilters <T>(elasticQuery);
Log.Debug("Search.Entities: {0} ({1}ms)",
found?.RequestInfo,
found?.TimeInMilliseconds);
if (found?.Exception == null)
{
return(CreateSearchResult(found));
}
return(CreateErrorResult(found));
}
public void ConstructorWithNoExpressionDefaultsExpressionPropertyToConstantOfQuery()
{
var query = new ElasticQuery<Sample>(provider);
Assert.IsType<ConstantExpression>(query.Expression);
Assert.Same(query, (((ConstantExpression)query.Expression)).Value);
}
public async Task <IActionResult> Content(
string indexName,
string query,
string parameters)
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.QueryElasticApi))
{
return(Unauthorized());
}
var luceneQuery = new ElasticQuery
{
Index = indexName,
Template = query,
ReturnContentItems = true
};
var queryParameters = parameters != null?
JsonConvert.DeserializeObject <Dictionary <string, object> >(parameters)
: new Dictionary <string, object>();
var result = await _luceneQuerySource.ExecuteQueryAsync(luceneQuery, queryParameters);
return(new ObjectResult(result));
}
public void Primaerdaten_Snippets_duerfen_nicht_fehlen_wenn_Titel_In_Metadaten_Vorkommt()
{
// arrange
var elasticSettings = new Mock <IElasticSettings>();
var userAccess = new UserAccess("123", AccessRoles.RoleBAR, null, null, false);
var query = new ElasticQuery();
var mockResponse = new
{
took = 1,
timed_out = false,
_shards = new
{
total = 2,
successful = 2,
failed = 0
},
hits = new
{
total = 1,
max_score = 1.0,
hits = new[]
{
new
{
_index = "project",
_type = "project",
_id = "Project",
_score = 1.0,
_source = new TreeRecord
{
ArchiveRecordId = "1",
PrimaryDataFulltextAccessTokens = new List <string> {
AccessRoles.RoleBAR
}
},
highlight = new
{
title = new[] { "<em>Titel</em>" },
all_Metadata_Text = new[] { "<em>Titel</em>" },
all_Primarydata = new[] { "<em>Primärdaten-Snippet</em>" }
}
}
}
}
};
var clientProvider = CreateClientProvider(mockResponse);
var service = new ElasticService(clientProvider, elasticSettings.Object);
// act
var result = service.RunQuery <TreeRecord>(query, userAccess);
// assert
result.Data.Items[0].Highlight["mostRelevantVektor"]
.Values <string>().First().Should()
.Be("<em>Primärdaten-Snippet</em>");
}
public void ConstructorsSetProviderProperty()
{
var firstConstructor = new ElasticQuery <Sample>(provider);
var secondConstructor = new ElasticQuery <Sample>(provider);
Assert.Same(provider, firstConstructor.Provider);
Assert.Same(provider, secondConstructor.Provider);
}
public Task <FindResults <T> > GetAllAsync(SortingOptions sorting = null, PagingOptions paging = null)
{
var search = new ElasticQuery()
.WithPaging(paging)
.WithSort(sorting);
return(FindAsync(search));
}
public void ElementTypePropertyReturnsGenericArgument()
{
var query = new ElasticQuery <Sample>(provider);
var elementType = query.ElementType;
Assert.Equal(typeof(Sample), elementType);
}
public void ConstructorsSetProviderProperty()
{
var firstConstructor = new ElasticQuery<Sample>(provider);
var secondConstructor = new ElasticQuery<Sample>(provider);
Assert.Same(provider, firstConstructor.Provider);
Assert.Same(provider, secondConstructor.Provider);
}
public void ElementTypePropertyReturnsGenericArgument()
{
var query = new ElasticQuery<Sample>(provider);
var elementType = query.ElementType;
Assert.Equal(typeof(Sample), elementType);
}
public void Where_On_Inner_Property_Generates_Correct_FieldName()
{
var where = new ElasticQuery<Outer>(SharedProvider).Where(o => o.Inner.Id == Guid.NewGuid());
var criteria = ElasticQueryTranslator.Translate(new CouchbaseElasticMapping(), where.Expression).SearchRequest.Filter;
var andCriteria = Assert.IsType<AndCriteria>(criteria);
var termsCriteria = andCriteria.Criteria.OfType<TermCriteria>().Single();
Assert.Equal("doc.inner.id", termsCriteria.Field);
}
public Task <ICollection <FacetResult> > GetFacetsAsync(string systemFilter, FacetOptions facets, string userFilter = null, string query = null)
{
var search = new ElasticQuery()
.WithSystemFilter(systemFilter)
.WithFilter(userFilter)
.WithSearchQuery(query, false)
.WithFacets(facets);
return(GetFacetsAsync(search));
}
public void Primaerdaten_Snippets_Muessen_Auf_Berechtigungen_geprueft_werden()
{
// arrange
var elasticSettings = new Mock <IElasticSettings>();
var userAccess = new UserAccess("123", AccessRoles.RoleOe1, null, null, false);
var query = new ElasticQuery();
var mockResponse = new
{
took = 1,
timed_out = false,
_shards = new
{
total = 2,
successful = 2,
failed = 0
},
hits = new
{
total = 1,
max_score = 1.0,
hits = new[]
{
new
{
_index = "project",
_type = "project",
_id = "Project",
_score = 1.0,
_source = new TreeRecord
{
ArchiveRecordId = "1",
PrimaryDataFulltextAccessTokens = new List <string> {
AccessRoles.RoleBAR
}
},
highlight = new
{
all_Primarydata = new[] { "<em>Geheimer</em>", "Dies ist ein <em>Geheimer</em> Text" }
}
}
}
}
};
var clientProvider = CreateClientProvider(mockResponse);
var service = new ElasticService(clientProvider, elasticSettings.Object);
// act
var result = service.RunQuery <TreeRecord>(query, userAccess);
// assert
result.Data.Items[0].Highlight["mostRelevantVektor"].Should().BeNullOrEmpty();
}
public void ConstantFalseDoesNotCauseConnection()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy);
var query = new ElasticQuery <Robot>(provider).Where(f => false);
((IEnumerable)query).GetEnumerator();
Assert.Empty(httpStub.Requests);
}
}
public Task <FindResults <T> > GetBySearchAsync(string systemFilter, string userFilter = null, string query = null, SortingOptions sorting = null, PagingOptions paging = null, FacetOptions facets = null)
{
var search = new ElasticQuery()
.WithSystemFilter(systemFilter)
.WithFilter(userFilter)
.WithSearchQuery(query, false)
.WithFacets(facets)
.WithSort(sorting)
.WithPaging(paging);
return(FindAsync(search));
}
public void SelectAnonymousProjectionTranslatesToNestedField()
{
var RobotsWithOs = new ElasticQuery <RobotWithOs>(SharedProvider);
var selected = RobotsWithOs.Select(r => new { r.OperatingSystem.Name });
var searchRequest = ElasticQueryTranslator.Translate(Mapping, selected.Expression).SearchRequest;
Assert.Equal("robotwithos", searchRequest.IndexType);
Assert.NotNull(searchRequest.Fields);
Assert.Contains("operatingSystem.name", searchRequest.Fields);
Assert.Equal(1, searchRequest.Fields.Count);
}
public static ElasticQuery WithParentQuery(this ElasticQuery query, Func <ParentQuery, ParentQuery> parentQueryFunc)
{
if (parentQueryFunc == null)
{
throw new ArgumentNullException(nameof(parentQueryFunc));
}
var parentQuery = query.ParentQuery as ParentQuery ?? new ParentQuery();
query.ParentQuery = parentQueryFunc(parentQuery);
return(query);
}
public static ElasticQuery WithParentQuery <T>(this ElasticQuery query, Func <T, T> parentQueryFunc) where T : class, IRepositoryQuery, new()
{
if (parentQueryFunc == null)
{
throw new ArgumentNullException(nameof(parentQueryFunc));
}
var parentQuery = query.ParentQuery as T ?? new T();
query.ParentQuery = parentQueryFunc(parentQuery);
return(query);
}
public static ElasticQuery WithChildQuery <T>(this ElasticQuery query, Func <T, T> childQueryFunc) where T : class, ITypeQuery, new()
{
if (childQueryFunc == null)
{
throw new ArgumentNullException(nameof(childQueryFunc));
}
var childQuery = query.ChildQuery as T ?? new T();
query.ChildQuery = childQueryFunc(childQuery);
return(query);
}
public static ElasticQuery WithChildQuery(this ElasticQuery query, Func <ChildQuery, ChildQuery> childQueryFunc)
{
if (childQueryFunc == null)
{
throw new ArgumentNullException(nameof(childQueryFunc));
}
var childQuery = query.ChildQuery as ChildQuery ?? new ChildQuery();
query.ChildQuery = childQueryFunc(childQuery);
return(query);
}
public void ProviderExecuteTCausesPostToConnectionEndpoint()
{
using (var httpStub = new HttpStub(ZeroHits))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery <Robot>(provider);
provider.Execute <IEnumerable <Robot> >(query.Expression);
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
}
}
public void ProviderExecuteTCausesPostToConnectionEndpoint()
{
using (var httpStub = new HttpStub(ZeroHits))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery<Robot>(provider);
provider.Execute<IEnumerable<Robot>>(query.Expression);
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
}
}
public void QueryImplicitGetEnumeratorCausesConnection()
{
using (var httpStub = new HttpStub(ZeroHits))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery <Robot>(provider);
var enumerator = query.GetEnumerator();
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
Assert.NotNull(enumerator);
}
}
public async void ProviderExecuteCausesPostToConnectionEndpoint()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy);
var query = new ElasticQuery <Robot>(provider);
provider.Execute(query.Expression);
await httpStub.Completion;
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/_all/robots/_search", request.RawUrl);
}
}
public static ElasticQuery BuildElasticQuery(SearchParameters searchFor, UserAccess access)
{
if (searchFieldDefinitionsByKey == null)
{
InitDictionaries();
}
var query = new ElasticQuery
{
SearchParameters = searchFor,
Query = CreateQueryForSearchModel(searchFor.Query, access)
};
return(query);
}
public async Task <NumbersStatsResult> GetNumbersStatsAsync(IEnumerable <FieldAggregation> fields, DateTime utcStart, DateTime utcEnd, IExceptionlessSystemFilterQuery systemFilter, string userFilter = null, TimeSpan?displayTimeOffset = null)
{
if (!displayTimeOffset.HasValue)
{
displayTimeOffset = TimeSpan.Zero;
}
var filter = new ElasticQuery()
.WithSystemFilter(systemFilter)
.WithFilter(userFilter)
.WithDateRange(utcStart, utcEnd, EventIndexType.Fields.Date)
.WithIndexes(utcStart, utcEnd);
// if no start date then figure out first event date
if (!filter.DateRanges.First().UseStartDate)
{
await UpdateFilterStartDateRangesAsync(filter, utcEnd).AnyContext();
}
utcStart = filter.DateRanges.First().GetStartDate();
utcEnd = filter.DateRanges.First().GetEndDate();
var descriptor = new SearchDescriptor <PersistentEvent>()
.SearchType(SearchType.Count)
.IgnoreUnavailable()
.Indices(_configuration.Events.Event.GetIndexesByQuery(filter))
.Type(_configuration.Events.Event.Name)
.Aggregations(agg => BuildAggregations(agg, fields));
_configuration.Events.Event.QueryBuilder.ConfigureSearch(filter, GetQueryOptions(), descriptor);
var response = await _configuration.Client.SearchAsync <PersistentEvent>(descriptor).AnyContext();
_logger.Trace(() => response.GetRequest());
if (!response.IsValid)
{
string message = $"Retrieving stats failed: {response.GetErrorMessage()}";
_logger.Error().Exception(response.ConnectionStatus.OriginalException).Message(message).Property("request", response.GetRequest()).Write();
throw new ApplicationException(message, response.ConnectionStatus.OriginalException);
}
return(new NumbersStatsResult {
Total = response.Total,
Start = utcStart.SafeAdd(displayTimeOffset.Value),
End = utcEnd.SafeAdd(displayTimeOffset.Value),
Numbers = GetNumbers(response.Aggs, fields)
});
}
public async void QueryExplicitIEnumerableGetEnumeratorCausesConnection()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy);
var query = new ElasticQuery <Robot>(provider);
var enumerator = ((IEnumerable)query).GetEnumerator();
await httpStub.Completion;
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/_all/robots/_search", request.RawUrl);
Assert.NotNull(enumerator);
}
}
public async Task <NumbersStatsResult> GetNumbersStatsAsync(IEnumerable <FieldAggregation> fields, DateTime utcStart, DateTime utcEnd, string systemFilter, string userFilter = null, TimeSpan?displayTimeOffset = null)
{
if (!displayTimeOffset.HasValue)
{
displayTimeOffset = TimeSpan.Zero;
}
var filter = new ElasticQuery()
.WithSystemFilter(systemFilter)
.WithFilter(userFilter)
.WithDateRange(utcStart, utcEnd, EventIndex.Fields.PersistentEvent.Date)
.WithIndices(utcStart, utcEnd, $"'{_eventIndex.VersionedName}-'yyyyMM");
// if no start date then figure out first event date
if (!filter.DateRanges.First().UseStartDate)
{
await UpdateFilterStartDateRangesAsync(filter, utcEnd).AnyContext();
}
utcStart = filter.DateRanges.First().GetStartDate();
utcEnd = filter.DateRanges.First().GetEndDate();
var response = await _elasticClient.SearchAsync <PersistentEvent>(s => s
.SearchType(SearchType.Count)
.IgnoreUnavailable()
.Index(filter.Indices.Count > 0 ? String.Join(",", filter.Indices) : _eventIndex.AliasName)
.Query(_queryBuilder.BuildQuery <PersistentEvent>(filter))
.Aggregations(agg => BuildAggregations(agg, fields))
).AnyContext();
if (!response.IsValid)
{
_logger.Error("Retrieving stats failed: {0}", response.ServerError.Error);
throw new ApplicationException("Retrieving stats failed.");
}
return(new NumbersStatsResult {
Total = response.Total,
Start = utcStart.SafeAdd(displayTimeOffset.Value),
End = utcEnd.SafeAdd(displayTimeOffset.Value),
Numbers = GetNumbers(response.Aggs, fields)
});
}
private async Task UpdateFilterStartDateRangesAsync(ElasticQuery filter, DateTime utcEnd)
{
// TODO: Cache this to save an extra search request when a date range isn't filtered.
var result = await _elasticClient.SearchAsync <PersistentEvent>(s => s
.IgnoreUnavailable()
.Index(filter.Indices.Count > 0 ? String.Join(",", filter.Indices) : _eventIndex.AliasName)
.Query(d => _queryBuilder.BuildQuery <PersistentEvent>(filter))
.SortAscending(ev => ev.Date)
.Take(1)).AnyContext();
var firstEvent = result.Hits.FirstOrDefault();
if (firstEvent != null)
{
filter.DateRanges.Clear();
filter.WithDateRange(firstEvent.Source.Date.UtcDateTime, utcEnd, EventIndex.Fields.PersistentEvent.Date);
filter.Indices.Clear();
filter.WithIndices(firstEvent.Source.Date.UtcDateTime, utcEnd, $"'{_eventIndex.VersionedName}-'yyyyMM");
}
}
public static string GetQueryJson(int pageSize, int page, QueryType type, string query)
{
if (string.IsNullOrWhiteSpace(query) && type != QueryType.All)
{
return(null);
}
var elasticQuery = new ElasticQuery()
{
From = pageSize * (page - 1),
Size = pageSize,
Query = new Elastic_OuterQuery()
};
if (type == QueryType.All)
{
elasticQuery.Query.MatchAll = new Elastic_MatchAll();
}
else
{
var start = type == QueryType.Contains ? "*" : "";
var end = type != QueryType.All ? "*" : "";
string q = queryStringFromquery(query, start, end);
elasticQuery.Query.Bool = new Elastic_Bool()
{
Must = new List <Elastic_QueryStringOuter>()
{
new Elastic_QueryStringOuter()
{
QueryString = new Elastic_QueryString()
{
Query = q
}
}
}
};
}
return(JsonConvert.SerializeObject(elasticQuery, Formatting.None));
}
private async Task <List <ViewOrganization> > PopulateOrganizationStatsAsync(List <ViewOrganization> viewOrganizations)
{
if (viewOrganizations.Count <= 0)
{
return(viewOrganizations);
}
var organizations = viewOrganizations.Select(o => new Organization {
Id = o.Id, CreatedUtc = o.CreatedUtc, RetentionDays = o.RetentionDays
}).ToList();
var sf = new ExceptionlessSystemFilterQuery(organizations);
var systemFilter = new ElasticQuery().WithSystemFilter(sf).WithDateRange(organizations.GetRetentionUtcCutoff(), SystemClock.UtcNow, (PersistentEvent e) => e.Date).WithIndexes(organizations.GetRetentionUtcCutoff(), SystemClock.UtcNow);
var result = await _eventRepository.CountBySearchAsync(systemFilter, null, $"terms:(organization_id~{viewOrganizations.Count} cardinality:stack_id)");
foreach (var organization in viewOrganizations)
{
var organizationStats = result.Aggregations.Terms <string>("terms_organization_id")?.Buckets.FirstOrDefault(t => t.Key == organization.Id);
organization.EventCount = organizationStats?.Total ?? 0;
organization.StackCount = (long?)organizationStats?.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0;
organization.ProjectCount = await _projectRepository.GetCountByOrganizationIdAsync(organization.Id);
}
return(viewOrganizations);
}
public void ConstructorSetsExpressionProperty()
{
var query = new ElasticQuery <Sample>(provider, validExpression);
Assert.Equal(validExpression, query.Expression);
}
public async void QueryExplicitIEnumerableGetEnumeratorCausesConnection()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery<Robot>(provider);
var enumerator = ((IEnumerable)query).GetEnumerator();
await httpStub.Completion;
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/_all/robots/_search", request.RawUrl);
Assert.NotNull(enumerator);
}
}
public void ConstantFalseDoesNotCauseConnection()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery<Robot>(provider).Where(f => false);
((IEnumerable)query).GetEnumerator();
Assert.Empty(httpStub.Requests);
}
}
public SearchResult Search(string index, string type, ElasticQuery elasticQuery)
{
string[] temp = null;
if (type != null) temp = new[] { type };
return Search(index, temp, elasticQuery);
}
public void ConstructorSetsExpressionProperty()
{
var query = new ElasticQuery<Sample>(provider, validExpression);
Assert.Equal(validExpression, query.Expression);
}
public void TestHighlight()
{
ElasticSearch.Client.ElasticSearchClient client=new ElasticSearchClient("localhost",9200,TransportType.Http);
string indexName = Guid.NewGuid().ToString();
client.CreateIndex(indexName);
TypeSetting type=new TypeSetting("type");
type.AddStringField("title").Analyzer = "whitespace";
type.AddStringField("snippet").Analyzer = "whitespace";
client.PutMapping(indexName, type);
//index sample
Dictionary<string, object> dict=new Dictionary<string, object>();
dict["title"] = "quick fox jump away";
dict["snippet"] = "quick fox jump away,where are you?";
client.Index(indexName, "type", "1", dict);
dict=new Dictionary<string, object>();
dict["title"] = "fox river is nearby";
dict["snippet"] = "where is fox river,where is it?";
client.Index(indexName, "type", "2", dict);
ElasticQuery query=new ElasticQuery(
new QueryStringQuery("fox")
.AddField("title",5)
.AddField("snippet",5),null,0,5 );
query.AddHighlightField(new HightlightField("title"));
query.AddHighlightField(new HightlightField("snippet"));
client.Refresh(indexName);
var result= client.Search(indexName, query);
Console.Out.WriteLine(result.Query);
Console.Out.WriteLine(result.Response);
Console.Out.WriteLine("---");
HitStatus hits = result.GetHits();
if (hits != null)
foreach (var o in hits.Hits)
{
foreach (var pair in o.Highlight)
{
Console.Out.WriteLine(pair.Key + ":");
foreach (var field in pair.Value)
{
Console.Out.WriteLine(field);
}
Console.Out.WriteLine();
}
}
client.DeleteIndex(indexName);
}
public void LinqMethodReturnsElasticQueryType()
{
var query = new ElasticQuery<Sample>(provider).Where(s => s.Text == "a");
Assert.IsType<ElasticQuery<Sample>>(query);
}
public async void ProviderExecuteCausesPostToConnectionEndpoint()
{
using (var httpStub = new HttpStub(ZeroHits, 1))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy);
var query = new ElasticQuery<Robot>(provider);
provider.Execute(query.Expression);
await httpStub.Completion;
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/_all/robots/_search", request.RawUrl);
}
}
public SearchResult Search(string index, string[] type, IQuery query,SortItem sortItem, int from, int size, string[] fields = null)
{
Contract.Assert(!string.IsNullOrEmpty(index));
Contract.Assert(query != null);
Contract.Assert(from >= 0);
Contract.Assert(size > 0);
var elasticQuery = new ElasticQuery(from, size);
elasticQuery.SetQuery(query);
if (sortItem != null)
{
elasticQuery.AddSortItem(sortItem);
}
if (fields != null) elasticQuery.AddFields(fields);
return Search(index, type, elasticQuery);
}
public SearchResult Search(string index, ElasticQuery elasticQuery)
{
return Search(index, new string[]{}, elasticQuery);
}
public void QueryImplicitGetEnumeratorCausesConnection()
{
using (var httpStub = new HttpStub(ZeroHits))
{
var provider = new ElasticQueryProvider(new ElasticConnection(httpStub.Uri), mapping, log, retryPolicy, "prefix");
var query = new ElasticQuery<Robot>(provider);
var enumerator = query.GetEnumerator();
var request = httpStub.Requests.Single();
Assert.Equal("POST", request.HttpMethod);
Assert.Equal("/robots/_search", request.RawUrl);
Assert.NotNull(enumerator);
}
}
public SearchResult Search(string index, string[] type, ElasticQuery elasticQuery)
{
string jsonstr = JsonSerializer.Get(elasticQuery);
string url;
if (type == null || type.Length == 0)
{
url = "/{0}/_search".Fill(index.ToLower());
}
else
{
url = "/{0}/{1}/_search".Fill(index.ToLower(), string.Join(",", type));
}
RestResponse result = _provider.Post(url, jsonstr);
var hitResult = new SearchResult(url,jsonstr,result.GetBody());
return hitResult;
}
