Implement GeoTileGrid aggregation (#3932)

Implement GeoTileGrid aggregation

Author: codebrain

src/Nest/Aggregations/AggregateDictionary.cs

@@ -174,6 +174,8 @@ public TermsAggregate<TKey> Terms<TKey>(string key)
 
 		public MultiBucketAggregate<KeyedBucket<string>> GeoHash(string key) => GetMultiKeyedBucketAggregate<string>(key);
 
+		public MultiBucketAggregate<KeyedBucket<string>> GeoTile(string key) => GetMultiKeyedBucketAggregate<string>(key);
+
 		public MultiBucketAggregate<KeyedBucket<string>> AdjacencyMatrix(string key) => GetMultiKeyedBucketAggregate<string>(key);
 
 		public MultiBucketAggregate<RangeBucket> Range(string key) => GetMultiBucketAggregate<RangeBucket>(key);

src/Nest/Aggregations/AggregationContainer.cs

@@ -149,6 +149,9 @@ public interface IAggregationContainer
 		[DataMember(Name = "geohash_grid")]
 		IGeoHashGridAggregation GeoHash { get; set; }
 
+		[DataMember(Name = "geotile_grid")]
+		IGeoTileGridAggregation GeoTile { get; set; }
+
 		[DataMember(Name = "global")]
 		IGlobalAggregation Global { get; set; }
 
@@ -300,6 +303,8 @@ public class AggregationContainer : IAggregationContainer
 
 		public IGeoHashGridAggregation GeoHash { get; set; }
 
+		public IGeoTileGridAggregation GeoTile { get; set; }
+
 		public IGlobalAggregation Global { get; set; }
 
 		public IHistogramAggregation Histogram { get; set; }
@@ -439,6 +444,8 @@ public class AggregationContainerDescriptor<T> : DescriptorBase<AggregationConta
 
 		IGeoHashGridAggregation IAggregationContainer.GeoHash { get; set; }
 
+		IGeoTileGridAggregation IAggregationContainer.GeoTile { get; set; }
+
 		IGlobalAggregation IAggregationContainer.Global { get; set; }
 
 		IHistogramAggregation IAggregationContainer.Histogram { get; set; }
@@ -565,6 +572,11 @@ Func<GeoHashGridAggregationDescriptor<T>, IGeoHashGridAggregation> selector
 		) =>
 			_SetInnerAggregation(name, selector, (a, d) => a.GeoHash = d);
 
+		public AggregationContainerDescriptor<T> GeoTile(string name,
+			Func<GeoTileGridAggregationDescriptor<T>, IGeoTileGridAggregation> selector
+		) =>
+			_SetInnerAggregation(name, selector, (a, d) => a.GeoTile = d);
+
 		public AggregationContainerDescriptor<T> GeoBounds(string name,
 			Func<GeoBoundsAggregationDescriptor<T>, IGeoBoundsAggregation> selector
 		) =>

src/Nest/Aggregations/Bucket/GeoTileGrid/GeoTileGridAggregation.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Linq.Expressions;
+using System.Runtime.Serialization;
+using Elasticsearch.Net.Utf8Json;
+
+namespace Nest
+{
+	[InterfaceDataContract]
+	[ReadAs(typeof(GeoTileGridAggregation))]
+	public interface IGeoTileGridAggregation : IBucketAggregation
+	{
+		/// <summary>
+		/// The name of the field indexed with GeoPoints.
+		/// </summary>
+		[DataMember(Name ="field")]
+		Field Field { get; set; }
+
+		/// <summary>
+		/// The zoom of the key used to define cells/buckets in the results.
+		/// </summary>
+		[DataMember(Name ="precision")]
+		GeoTilePrecision? Precision { get; set; }
+
+		/// <summary>
+		/// To allow for more accurate counting of the top cells returned in the final result the aggregation.
+		/// </summary>
+		[DataMember(Name ="shard_size")]
+		int? ShardSize { get; set; }
+
+		/// <summary>
+		/// The maximum number of geohash buckets to return.
+		/// </summary>
+		[DataMember(Name ="size")]
+		int? Size { get; set; }
+	}
+
+	public class GeoTileGridAggregation : BucketAggregationBase, IGeoTileGridAggregation
+	{
+		internal GeoTileGridAggregation() { }
+
+		public GeoTileGridAggregation(string name) : base(name) { }
+
+		/// <inheritdoc />
+		public Field Field { get; set; }
+
+		/// <inheritdoc />
+		public GeoTilePrecision? Precision { get; set; }
+
+		/// <inheritdoc />
+		public int? ShardSize { get; set; }
+
+		/// <inheritdoc />
+		public int? Size { get; set; }
+
+		internal override void WrapInContainer(AggregationContainer c) => c.GeoTile = this;
+	}
+
+	public class GeoTileGridAggregationDescriptor<T>
+		: BucketAggregationDescriptorBase<GeoTileGridAggregationDescriptor<T>, IGeoTileGridAggregation, T>
+			, IGeoTileGridAggregation
+		where T : class
+	{
+		Field IGeoTileGridAggregation.Field { get; set; }
+
+		GeoTilePrecision? IGeoTileGridAggregation.Precision { get; set; }
+
+		int? IGeoTileGridAggregation.ShardSize { get; set; }
+
+		int? IGeoTileGridAggregation.Size { get; set; }
+
+		/// <inheritdoc cref="IGeoTileGridAggregation.Field" />
+		public GeoTileGridAggregationDescriptor<T> Field(Field field) => Assign(field, (a, v) => a.Field = v);
+
+		/// <inheritdoc cref="IGeoTileGridAggregation.Field" />
+		public GeoTileGridAggregationDescriptor<T> Field<TValue>(Expression<Func<T, TValue>> field) => Assign(field, (a, v) => a.Field = v);
+
+		/// <inheritdoc cref="IGeoTileGridAggregation.Size" />
+		public GeoTileGridAggregationDescriptor<T> Size(int? size) => Assign(size, (a, v) => a.Size = v);
+
+		/// <inheritdoc cref="IGeoTileGridAggregation.ShardSize" />
+		public GeoTileGridAggregationDescriptor<T> ShardSize(int? shardSize) => Assign(shardSize, (a, v) => a.ShardSize = v);
+
+		/// <inheritdoc cref="IGeoTileGridAggregation.Precision" />
+		public GeoTileGridAggregationDescriptor<T> Precision(GeoTilePrecision? precision) =>
+			Assign(precision, (a, v) => a.Precision = v);
+	}
+}

src/Nest/Aggregations/Bucket/GeoTileGrid/GeoTilePrecision.cs

@@ -0,0 +1,104 @@
+namespace Nest
+{
+	public enum GeoTilePrecision
+	{
+		/// <summary>
+		/// Whole world
+		/// </summary>
+		Precision0 = 0,
+		Precision1 = 1,
+
+		/// <summary>
+		/// Subcontinental area
+		/// </summary>
+		Precision2 = 2,
+
+		/// <summary>
+		/// Largest Country
+		/// </summary>
+		Precision3 = 3,
+		Precision4 = 4,
+
+		/// <summary>
+		/// Large African Country
+		/// </summary>
+		Precision5 = 5,
+
+		/// <summary>
+		/// Large European Country
+		/// </summary>
+		Precision6 = 6,
+
+		/// <summary>
+		/// Small Country / US State
+		/// </summary>
+		Precision7 = 7,
+		Precision8 = 8,
+
+		/// <summary>
+		/// Wide Area / Large Metropolitan Area
+		/// </summary>
+		Precision9 = 9,
+
+		/// <summary>
+		/// Metropolitan Area
+		/// </summary>
+		Precision10 = 10,
+
+		/// <summary>
+		/// City
+		/// </summary>
+		Precision11 = 11,
+
+		/// <summary>
+		/// City / Town / District
+		/// </summary>
+		Precision12 = 12,
+
+		/// <summary>
+		/// Village / Suburb
+		/// </summary>
+		Precision13 = 13,
+		Precision14 = 14,
+
+		/// <summary>
+		/// Small Road
+		/// </summary>
+		Precision15 = 15,
+
+		/// <summary>
+		/// Street
+		/// </summary>
+		Precision16 = 16,
+
+		/// <summary>
+		/// Block / Park / Addresses
+		/// </summary>
+		Precision17 = 17,
+
+		/// <summary>
+		/// Some Buildings / Trees
+		/// </summary>
+		Precision18 = 18,
+
+		/// <summary>
+		/// Local highway / Crossing
+		/// </summary>
+		Precision19 = 19,
+		Precision20 = 20,
+		Precision21 = 21,
+		Precision22 = 22,
+		Precision23 = 23,
+		Precision24 = 24,
+		Precision25 = 25,
+		Precision26 = 26,
+		Precision27 = 27,
+		Precision28 = 28,
+
+		/// <summary>
+		/// Produces cells that cover less than a 10cm by 10cm of land and so high-precision
+		/// requests can be very costly in terms of RAM and result sizes.
+		/// </summary>
+		Precision29 = 29
+	}
+}

src/Nest/Aggregations/Visitor/AggregationVisitor.cs

@@ -52,6 +52,8 @@ public interface IAggregationVisitor
 
 		void Visit(IGeoHashGridAggregation aggregation);
 
+		void Visit(IGeoTileGridAggregation aggregation);
+
 		void Visit(IGeoBoundsAggregation aggregation);
 
 		void Visit(IHistogramAggregation aggregation);
@@ -143,6 +145,8 @@ public virtual void Visit(IFiltersAggregation aggregation) { }
 
 		public virtual void Visit(IGeoHashGridAggregation aggregation) { }
 
+		public virtual void Visit(IGeoTileGridAggregation aggregation) { }
+
 		public virtual void Visit(IHistogramAggregation aggregation) { }
 
 		public virtual void Visit(IIpRangeAggregation aggregation) { }

src/Nest/Aggregations/Visitor/AggregationWalker.cs

@@ -81,6 +81,11 @@ public void Walk(IAggregationContainer aggregation, IAggregationVisitor visitor)
 				v.Visit(d);
 				Accept(v, d.Aggregations);
 			});
+			AcceptAggregation(aggregation.GeoTile, visitor, (v, d) =>
+			{
+				v.Visit(d);
+				Accept(v, d.Aggregations);
+			});
 			AcceptAggregation(aggregation.Global, visitor, (v, d) =>
 			{
 				v.Visit(d);

src/Tests/Tests/Aggregations/Bucket/GeoHashTile/GeoTileGridAggregationUsageTests.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Linq;
+using FluentAssertions;
+using Nest;
+using Tests.Core.Extensions;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Domain;
+using Tests.Framework.EndpointTests.TestState;
+using static Nest.Infer;
+
+namespace Tests.Aggregations.Bucket.GeoTileGrid
+{
+	public class GeoTileTileAggregationUsageTests : AggregationUsageTestBase
+	{
+		public GeoTileTileAggregationUsageTests(ReadOnlyCluster i, EndpointUsage usage) : base(i, usage) { }
+
+		protected override object AggregationJson => new
+		{
+			my_geotile = new
+			{
+				geotile_grid = new
+				{
+					field = "locationPoint",
+					precision = 3,
+					size = 1000,
+					shard_size = 100
+				}
+			}
+		};
+
+		protected override Func<AggregationContainerDescriptor<Project>, IAggregationContainer> FluentAggs => a => a
+			.GeoTile("my_geotile", g => g
+				.Field(p => p.LocationPoint)
+				.Precision(GeoTilePrecision.Precision3)
+				.Size(1000)
+				.ShardSize(100)
+			);
+
+		protected override AggregationDictionary InitializerAggs =>
+			new GeoTileGridAggregation("my_geotile")
+			{
+				Field = Field<Project>(p => p.LocationPoint),
+				Precision = GeoTilePrecision.Precision3,
+				Size = 1000,
+				ShardSize = 100
+			};
+
+		protected override void ExpectResponse(ISearchResponse<Project> response)
+		{
+			response.ShouldBeValid();
+			var myGeoTileTile = response.Aggregations.GeoTile("my_geotile");
+			myGeoTileTile.Should().NotBeNull();
+			myGeoTileTile.Buckets.FirstOrDefault(r => r.Key == "3/0/4").Should().NotBeNull();
+			myGeoTileTile.Buckets.FirstOrDefault(r => r.Key == "3/5/5").Should().NotBeNull();
+		}
+	}
+}