private static void AssertPercentilesAggregate(AggregateDictionary bucket, string name) { var percentilesAggregate = bucket.Percentiles(name); percentilesAggregate.Should().NotBeNull(); percentilesAggregate.Items.Should().HaveCount(1).And.Contain(p => Math.Abs(p.Percentile - 50d) < double.Epsilon); }
public void SetUp() { callback = MockRepository.GenerateMock <IDictionaryCallback>(); dict1 = new Dictionary <string, object> { { "a", 1 }, { "b", 2 }, { "c", 3 } }; dict2 = new Dictionary <string, object> { { "d", 4 }, { "e", 5 }, { "f", 6 } }; dict3 = new Dictionary <string, object> { { "g", 7 }, { "h", 8 }, { "i", 9 } }; aggregate = new AggregateDictionary(); aggregate.AddLocator(RequestDataSource.Route, key => dict1.ContainsKey(key) ? dict1[key] : null, () => dict1.Keys); aggregate.AddLocator(RequestDataSource.Request, key => dict2.ContainsKey(key) ? dict2[key] : null, () => dict2.Keys); aggregate.AddLocator(RequestDataSource.Header, key => dict3.ContainsKey(key) ? dict3[key] : null, () => dict3.Keys); }
protected void OpenDictionary() { persistentSource = new FileBasedPersistentSource(tempPath, "test_", TransactionMode.Safe); aggregateDictionary = new AggregateDictionary(persistentSource); persistentDictionary = aggregateDictionary.Add(new PersistentDictionary(persistentSource, JTokenComparer.Instance)); aggregateDictionary.Initialze(); }
public override bool OnData(object data) { if (!(data is DataType)) { throw new BlockTypeMismatchException(typeof(DataType), data.GetType(), this); } var d = (DataType)data; // :HACK: lol if (isAggregator) { List <DataType> temp; AggregateDictionary.TryGetValue(KeyFunction(d), out temp); if (temp == null) { AggregateDictionary[KeyFunction(d)] = new List <DataType>(); } AggregateDictionary[KeyFunction(d)].Add(d); SendToChildren(AggregateDictionary); } else { Dictionary[KeyFunction(d)] = d; SendToChildren(Dictionary); } return(false); }
public static double ObterBucketAggregationDouble(AggregateDictionary agg, string bucket) { if (agg.BucketScript(bucket).Value.HasValue) { return(agg.BucketScript(bucket).Value.Value); } return(0); }
public void SetUp() { dictionary = new Dictionary<string, object>(); aggregate = new AggregateDictionary(); aggregate.AddDictionary(dictionary); request = new RequestData(aggregate); }
private static void AssertExtendedStats(AggregateDictionary bucket, string name) { var extendedStatsAggregate = bucket.ExtendedStats(name); extendedStatsAggregate.Should().NotBeNull(); extendedStatsAggregate.Count.Should().BeGreaterOrEqualTo(0); extendedStatsAggregate.StdDeviationBounds.Should().NotBeNull(); }
public void SetUp() { dictionary = new Dictionary<string, object>(); aggregate = new AggregateDictionary(); aggregate.AddLocator(RequestDataSource.Route, key => dictionary.ContainsKey(key) ? dictionary[key] : null); request = new RequestData(aggregate); }
public void SetUp() { dictionary = new Dictionary <string, object>(); aggregate = new AggregateDictionary(); aggregate.AddDictionary(dictionary); request = new RequestData(aggregate); }
public IHttpHandler GetHttpHandler(RequestContext requestContext) { var dictionary = new AggregateDictionary(requestContext); ServiceArguments arguments = new ServiceArguments().With(dictionary); IActionBehavior behavior = GetBehavior(arguments); return(new FubuHttpHandler(behavior)); }
public void indexer_should_find_value_with_one_locator_registered() { var values = new NameValueCollection { { "foo", "value" } }; var dict = new AggregateDictionary(); dict.AddLocator(s => values[s]); dict["foo"].ShouldEqual("value"); }
public IHttpHandler GetHttpHandler(RequestContext requestContext) { var dictionary = new AggregateDictionary(requestContext); ServiceArguments arguments = new ServiceArguments().With(dictionary); IActionBehavior behavior = GetBehavior(arguments); return new FubuHttpHandler(behavior); }
public static StatsAggregate GetStats <T>(this AggregateDictionary aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Stats); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.Stats(aggName); return(itemsTerms); }
public static IList <PercentileItem> GetPercentile <T>(this AggregateDictionary aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Percentile); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.Percentiles(aggName); return(itemsTerms.Items); }
protected void OpenDictionary() { persistentSource = new FileBasedPersistentSource(Path.GetTempPath(), "test_", TransactionMode.Lazy); aggregateDictionary = new AggregateDictionary(persistentSource); persistentDictionaryOne = aggregateDictionary.Add(new PersistentDictionary(persistentSource, JTokenComparer.Instance)); persistentDictionaryTwo = aggregateDictionary.Add(new PersistentDictionary(persistentSource, JTokenComparer.Instance)); aggregateDictionary.Initialze(); }
public void should_never_find_uri_value_from_request_property() { var requestCtx = Do_the_Stupid_ASPNET_Mock_HokeyPokey(); aggregate = new AspNetAggregateDictionary(requestCtx); forKey("Url"); assertWasNotFound(); }
public DebugReport(AggregateDictionary dictionary, ICurrentHttpRequest request) { _dictionary = dictionary; _request = request; Id = Guid.NewGuid(); FormData = new Dictionary <string, object>(); Headers = new Dictionary <string, string>(); Time = DateTime.Now; }
public static TK GetAverage <T, TK>(this AggregateDictionary aggs, Expression <Func <T, TK> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Average); aggWithResult.CheckForAggregationInResult(aggName); var avgAgg = aggWithResult.Average(aggName); return(ValueAsUndType <TK>(avgAgg)); }
public static TK GetFirstBy <T, TK>(this AggregateDictionary aggs, Expression <Func <T, TK> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.First); aggWithResult.CheckForAggregationInResult(aggName); var termsAgg = aggWithResult.Terms(aggName); return(Filters.StringToAnything <TK>(termsAgg.Buckets.First().Key)); }
public static int GetCardinality <T>(this AggregateDictionary aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Cardinality); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.Cardinality(aggName); return((int)itemsTerms.Value.Value); }
public void find_uri_value_from_request_property() { var expectedValue = new Uri("http://localhost/foo"); var requestCtx = Do_the_Stupid_ASPNET_Mock_HokeyPokey(); aggregate = new AspNetAggregateDictionary(requestCtx); forKey("Url"); assertFound(RequestDataSource.RequestProperty, expectedValue); }
public void TryGetValue_should_find_value_with_one_locator_registered() { var values = new NameValueCollection { { "foo", "value" } }; var dict = new AggregateDictionary(); dict.AddLocator(s => values[s]); object value; dict.TryGetValue("foo", out value).ShouldBeTrue(); value.ShouldEqual("value"); }
public void indexer_should_not_error_if_no_locator_finds_the_value() { var values1 = new NameValueCollection { { "foo", "value" } }; var values2 = new NameValueCollection { { "bar", "baz" } }; var dict = new AggregateDictionary(); dict.AddLocator(s => values1[s]); dict.AddLocator(s => values2[s]); dict["zzzz"].ShouldBeNull(); }
public void indexer_should_find_value_with_multiple_locators_registered() { var values1 = new NameValueCollection { { "foo", "value" } }; var values2 = new NameValueCollection { { "bar", "baz" } }; var dict = new AggregateDictionary(); dict.AddLocator(s => values1[s]); dict.AddLocator(s => values2[s]); dict["bar"].ShouldEqual("baz"); }
public void find_value_from_request_property() { const string expectedValue = "STUBBED USERAGENT"; var requestCtx = Do_the_Stupid_ASPNET_Mock_HokeyPokey(); requestCtx.HttpContext.Request.Stub(r => r.UserAgent).Return(expectedValue); aggregate = new AspNetAggregateDictionary(requestCtx); forKey("UserAgent"); assertFound(RequestDataSource.RequestProperty, expectedValue); }
public static string FindPath(AggregateDictionary dictionary) { var routeData = dictionary.DataFor(RequestDataSource.Route.ToString()); var list = new List <string>(); for (var i = 0; i < 10; i++) { routeData.Value("Part" + i, o => list.Add(o.ToString())); } return(list.Join("/")); }
public void TryGetValue_should_find_value_with_multiple_locators_registered() { var values1 = new NameValueCollection { { "foo", "value" } }; var values2 = new NameValueCollection { { "bar", "baz" } }; var dict = new AggregateDictionary(); dict.AddLocator(s => values1[s]); dict.AddLocator(s => values2[s]); object value; dict.TryGetValue("bar", out value).ShouldBeTrue(); value.ShouldEqual("baz"); }
public void request_for_url_should_come_from_the_server_variables_not_RequestProperty() { var expectedValue = "ServerVariables URL"; var requestCtx = Do_the_Stupid_ASPNET_Mock_HokeyPokey(); var request = requestCtx.HttpContext.Request; request.Stub(r => r["Url"]).Return(expectedValue); aggregate = new AspNetAggregateDictionary(requestCtx); forKey("Url"); assertFound(RequestDataSource.Request, expectedValue); }
public static AggregateDictionary GetAggregationContainingResult <T>(this AggregateDictionary aggs, Expression <Func <T, object> > filterRule = null) { if (filterRule == null) { return(aggs); } var filterName = filterRule.GenerateFilterName(); aggs.CheckForAggregationInResult(filterName); return(aggs.Filter(filterName)); }
public void SetUp() { var container = StructureMapContainerFacility.GetBasicFubuContainer(); theHeaderDictionary = new Dictionary <string, object>(); var dictionary = new AggregateDictionary(); dictionary.AddDictionary(RequestDataSource.Header.ToString(), theHeaderDictionary); container.Inject(dictionary); theHeaders = container.GetInstance <RequestHeaders>(); }
/// <summary> /// Checks if aggregation with given name is available on the result and throws if not /// </summary> public static void CheckForAggregationInResult(this AggregateDictionary aggs, string aggName) { if (aggs == null || aggs.Count == 0) { throw new InvalidOperationException("No aggregations available on the result"); } if (!aggs.ContainsKey(aggName)) { var availableAggregations = aggs.Select(x => x.Key).Aggregate((agg, x) => agg + "m" + x); throw new InvalidOperationException($"Aggregation {aggName} not in the result. Available aggregations: {availableAggregations}"); } }
public static int?GetCount <T>(this AggregateDictionary aggs, Expression <Func <T, object> > fieldGetter, Expression <Func <T, object> > filterRule = null) { var aggWithResult = GetAggregationContainingResult(aggs, filterRule); var aggName = fieldGetter.GetAggName(AggType.Count); aggWithResult.CheckForAggregationInResult(aggName); var itemsTerms = aggWithResult.ValueCount(aggName); if (!itemsTerms.Value.HasValue) { return(null); } return((int)itemsTerms.Value); }
public void find_value_from_request_property_of_added_aggregate() { const string expectedValue = "STUBBED USERAGENT"; aggregate = new AggregateDictionary(); aggregate.AddDictionary("Other", new Dictionary <string, object> { { "UserAgent", expectedValue } }); forKey("UserAgent1"); callback.AssertWasNotCalled(x => x.Callback(RequestDataSource.Other.ToString(), null), o => o.IgnoreArguments()); forKey("UserAgent"); assertFound(RequestDataSource.Other, expectedValue); }
public void SetUp() { theServiceArguments = new ServiceArguments(); theDictionary = new AggregateDictionary(); theHeaders = new Dictionary <string, object>(); theDictionary.AddDictionary(RequestDataSource.Header.ToString(), theHeaders); theServiceArguments.Set(typeof(AggregateDictionary), theDictionary); stash <IHttpWriter>(); stash <ICurrentChain>(); theCache = new EtagCache(); theFilter = new AssetEtagInvocationFilter(theCache); }
public void SetUp() { theBinder = StandardModelBinder.Basic().As <StandardModelBinder>(); theAggregateDictionary = new AggregateDictionary(); var otherDictionary = new Dictionary <string, object>(); for (int i = 0; i < 10; i++) { otherDictionary.Add("Part" + i, Guid.NewGuid().ToString()); } theAggregateDictionary.AddDictionary(RequestDataSource.Request.ToString(), otherDictionary); theRouteValues = new Dictionary <string, object>(); theAggregateDictionary.AddDictionary(RequestDataSource.Route.ToString(), theRouteValues); }
private List <Aggregation> BuildAggregations(AggregateDictionary aggregations) { if (aggregations.Count == 0) { return(null); } List <Aggregation> aggResult = new List <Aggregation>(); foreach (var esAggResult in aggregations) { aggResult.Add(new Aggregation { aggregationName = esAggResult.Key, aggregationField = esAggResult.Key, docCount = ((BucketAggregate)esAggResult.Value).Items.Count, filters = BuildFilters(((BucketAggregate)esAggResult.Value).Items) }); } return(aggResult); }
/// <summary> /// Die Methode für die folgenden Filterungen durch: /// - Es wird nur eine creationPeriod Facette zurückgegeben /// - Aggregationen die mit 'facet_' beginnen werden nicht zurückgegeben. Stattdessen wird das Child von diesen /// Aggregationen zurückgegeben. /// </summary> private Dictionary <string, IAggregate> GetfilteredAggregations(AggregateDictionary aggs, FacetFilters[] facetsFilters, out string chosenCreationPeriodAggregation) { var filteredAggregations = new Dictionary <string, IAggregate>(); var found = false; chosenCreationPeriodAggregation = string.Empty; foreach (var entry in aggs.OrderBy(t => t.Key)) { if (entry.Key.StartsWith("facet_aggregationFields.creationPeriodYears")) { if (!found) { var primaryAggregation = ((SingleBucketAggregate)entry.Value).First().Value; // Wähle den Bucket, der weniger als 10 Einträge hat. Oder dann ganz am Ende den Jahrhundertfilter if (GetSelectedCreationPeriod(facetsFilters) == string.Empty && (((BucketAggregate)primaryAggregation).Items.Count < 10 || entry.Key == "facet_aggregationFields.creationPeriodYears100" ) || GetSelectedCreationPeriod(facetsFilters) == entry.Key) { filteredAggregations.Add("aggregationFields.creationPeriodYears", primaryAggregation); found = true; chosenCreationPeriodAggregation = entry.Key.Remove(0, 6); } } } else if (entry.Key.StartsWith("facet_")) { var primaryAggregation = ((SingleBucketAggregate)entry.Value).First().Value; filteredAggregations.Add(entry.Key.Remove(0, 6), primaryAggregation); } else { filteredAggregations.Add(entry.Key, entry.Value); } } return(filteredAggregations); }
private static IEnumerable <AggregationResult> GetAggregationResultsFrom(AggregateDictionary aggregations) { if (aggregations == null) { return(Enumerable.Empty <AggregationResult>()); } var terms = aggregations.Terms(SubCategoriesAggregationName); if (terms == null) { return(Enumerable.Empty <AggregationResult>()); } var items = terms.Buckets.Select(bucket => new AggregationResult { Code = bucket.Key, Count = bucket.DocCount.GetValueOrDefault(0) }); return(items); }
private ISearchResponse <Document> DoSearch(int?skip) { lastskip = skip ?? 0; ISearchResponse <Document> searchResult; if (_luceneQuery != null) { _queryContainer = new QueryContainer(new QueryStringQuery() { Query = _luceneQuery.ToString(), AnalyzeWildcard = true }); } if (_queryContainer != null) { SearchDescriptor <Document> searchDescriptor = new SearchDescriptor <Document>(); searchDescriptor.Index(_indexName) .Skip(skip) .Size(_maxResults) .Query(q => _queryContainer) .Sort(s => _sortDescriptor); var json = _client.RequestResponseSerializer.SerializeToString(searchDescriptor); searchResult = _client.Search <Document>(searchDescriptor); } else if (_searchRequest != null) { searchResult = _client.Search <Document>(_searchRequest); } else { searchResult = _client.Search <Document>(_searchSelector); } TotalItemCount = searchResult.Total; Aggregation = searchResult.Aggregations; return(searchResult); }
public static IEnumerable <V> GetDistinct <T, V>(this AggregateDictionary aggs, Expression <Func <T, V> > fieldGetter) { var aggName = fieldGetter.GetAggName(AggType.Distinct); var itemsTerms = aggs.Terms(aggName); var targetType = typeof(V); if (targetType.IsEnum) { return(itemsTerms.Buckets.Select((x => Filters.Parse <V>(x.Key)))); } if (targetType == typeof(string)) { return(itemsTerms.Buckets.Select(x => x.Key).Cast <V>()); } if (targetType == typeof(long) || targetType == typeof(int)) { return(itemsTerms.Buckets.Select(x => long.Parse(x.Key)).Cast <V>()); } throw new NotImplementedException("You can get only distinct values of Strings, Enums, ints or long"); }
public void indxer_should_work_without_any_locators_registered() { var dict = new AggregateDictionary(); dict["foo"].ShouldBeNull(); }
public void TryGetValue_should_work_without_any_locators_registered() { var dict = new AggregateDictionary(); object value; dict.TryGetValue("foo", out value).ShouldBeFalse(); value.ShouldBeNull(); }
public void TryGetValue_should_not_error_if_no_locator_finds_the_value() { var values1 = new NameValueCollection { { "foo", "value" } }; var values2 = new NameValueCollection { { "bar", "baz" } }; var dict = new AggregateDictionary(); dict.AddLocator(s => values1[s]); dict.AddLocator(s => values2[s]); object value; dict.TryGetValue("zzzz", out value).ShouldBeFalse(); value.ShouldBeNull(); }