Add support for geo_shape represented as Well-Known Text (WKT) (#3377)

* Add support for well known text (wkt) to geo bounding box queries
* Move geo_shape queries into Tests project

This commit moves the geo_shape queries into the Test project.
Missed in the Tests refactoring

* Add support for Z values to GeoCoordinate
* Add support for WKT geo shapes

This commit adds support for Well-Known Text (WKT) representations
of geo_shape. The extent of the implementation is only as far as is
required by the WKT support in Elasticsearch.

Deserialize from WKT to IGeoShape types. The format from which
the shape is deserialized is assigned to an internal format property
on the concrete implementations of GeoShape as the intention is
not to expose this as a property on the IGeoShape interface. The format
is assigned to the instance so that the IGeoShape instance is
serialized to the same format if indexed again.

GeoWKTReader is a simple tokenizer implementation
for the purposes of parsing only WKT concepts that are supported
by Elasticsearch.

GeoShapeConverter now implements WriteJson because the
original format of IGeoShape now needs to be taken into account
when serializing.

Add tests for roundtrip serialization of WKT.

Closes #3256

Author: russcam

src/Nest/QueryDsl/Geo/BoundingBox/BoundingBox.cs

@@ -10,26 +10,30 @@ public interface IBoundingBox
 
 		[JsonProperty("bottom_right")]
 		GeoLocation BottomRight { get; set; }
+
+		[JsonProperty("wkt")]
+		string WellKnownText { get; set; }
 	}
 
 	public class BoundingBox : IBoundingBox
 	{
 		public GeoLocation TopLeft { get; set; }
 		public GeoLocation BottomRight { get; set; }
+		public string WellKnownText { get; set; }
 	}
 
 	public class BoundingBoxDescriptor : DescriptorBase<BoundingBoxDescriptor, IBoundingBox>, IBoundingBox
 	{
 		GeoLocation IBoundingBox.TopLeft { get; set; }
 		GeoLocation IBoundingBox.BottomRight { get; set; }
+		string IBoundingBox.WellKnownText { get; set; }
 
-		
 		public BoundingBoxDescriptor TopLeft(GeoLocation topLeft) => Assign(a => a.TopLeft = topLeft);
 		public BoundingBoxDescriptor TopLeft(double lat, double lon) => Assign(a => a.TopLeft = new GeoLocation(lat,lon));
 
 		public BoundingBoxDescriptor BottomRight(GeoLocation bottomRight) => Assign(a => a.BottomRight = bottomRight);
 		public BoundingBoxDescriptor BottomRight(double lat, double lon) => Assign(a => a.BottomRight = new GeoLocation(lat, lon));
 
-		
+		public BoundingBoxDescriptor WellKnownText(string wkt)=> Assign(a => a.WellKnownText = wkt);
 	}
-}
+}

src/Nest/QueryDsl/Geo/BoundingBox/GeoBoundingBoxQuery.cs

@@ -29,7 +29,7 @@ public class GeoBoundingBoxQuery : FieldNameQueryBase, IGeoBoundingBoxQuery
 		internal override void InternalWrapInContainer(IQueryContainer c) => c.GeoBoundingBox = this;
 
 		internal static bool IsConditionless(IGeoBoundingBoxQuery q) =>
-			q.Field.IsConditionless() || q.BoundingBox?.BottomRight == null || q.BoundingBox?.TopLeft == null;
+			q.Field.IsConditionless() || (q.BoundingBox?.BottomRight == null && q.BoundingBox?.TopLeft == null && q.BoundingBox?.WellKnownText == null);
 	}
 
 	public class GeoBoundingBoxQueryDescriptor<T>
@@ -47,6 +47,9 @@ public GeoBoundingBoxQueryDescriptor<T> BoundingBox(double topLeftLat, double to
 		public GeoBoundingBoxQueryDescriptor<T> BoundingBox(GeoLocation topLeft, GeoLocation bottomRight) =>
 			BoundingBox(f=>f.TopLeft(topLeft).BottomRight(bottomRight));
 
+		public GeoBoundingBoxQueryDescriptor<T> BoundingBox(string wkt) =>
+			BoundingBox(f=>f.WellKnownText(wkt));
+
 		public GeoBoundingBoxQueryDescriptor<T> BoundingBox(Func<BoundingBoxDescriptor, IBoundingBox> boundingBoxSelector) =>
 			Assign(a => a.BoundingBox = boundingBoxSelector?.Invoke(new BoundingBoxDescriptor()));
 

src/Nest/QueryDsl/Geo/GeoCoordinateJsonConverter.cs

@@ -17,15 +17,24 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 			writer.WriteStartArray();
 			serializer.Serialize(writer, p.Longitude);
 			serializer.Serialize(writer, p.Latitude);
+			if (p.Z.HasValue)
+				serializer.Serialize(writer, p.Z.Value);
 			writer.WriteEndArray();
 		}
 
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
 			if (reader.TokenType != JsonToken.StartArray) return null;
 			var doubles = serializer.Deserialize<double[]>(reader);
-			if (doubles.Length != 2) return null;
-			return new GeoCoordinate(doubles[1], doubles[0]);
+			switch (doubles.Length)
+			{
+				case 2:
+					return new GeoCoordinate(doubles[1], doubles[0]);
+				case 3:
+					return new GeoCoordinate(doubles[1], doubles[0], doubles[2]);
+				default:
+					return null;
+			}
 		}
 	}
-}
+}

src/Nest/QueryDsl/Geo/GeoLocation.cs

@@ -123,7 +123,8 @@ public static implicit operator GeoLocation(double[] lonLat)
 	}
 
 	/// <summary>
-	/// Represents a Latitude/Longitude as a 2 dimensional point that gets serialized as new [] { lon, lat }
+	/// Represents a Latitude/Longitude and optional Z value as a 2 or 3 dimensional point
+	/// that gets serialized as new [] { lon, lat, [z] }
 	/// </summary>
 	[JsonConverter(typeof(GeoCoordinateJsonConverter))]
 	public class GeoCoordinate : GeoLocation
@@ -134,17 +135,35 @@ public class GeoCoordinate : GeoLocation
 		public GeoCoordinate(double latitude, double longitude) : base(latitude, longitude) { }
 
 		/// <summary>
-		/// Creates a new instance of <see cref="GeoCoordinate"/> from a pair of coordinates
-		/// in the order Latitude then Longitude.
+		/// Creates a new instance of <see cref="GeoCoordinate"/>
+		/// </summary>
+		public GeoCoordinate(double latitude, double longitude, double z) : base(latitude, longitude) =>
+			Z = z;
+
+		/// <summary>
+		/// Gets or sets the Z value
+		/// </summary>
+		public double? Z { get; set; }
+
+		/// <summary>
+		/// Creates a new instance of <see cref="GeoCoordinate"/> from an array
+		/// of 2 or 3 doubles, in the order Latitude, Longitude, and optional Z value.
 		/// </summary>
 		public static implicit operator GeoCoordinate(double[] coordinates)
 		{
-			if (coordinates == null || coordinates.Length != 2)
-				throw new ArgumentOutOfRangeException(
-					nameof(coordinates),
-					$"Can not create a {nameof(GeoCoordinate)} from an array that does not have two doubles");
-
-			return new GeoCoordinate(coordinates[0], coordinates[1]);
+			if (coordinates == null) return null;
+
+			switch (coordinates.Length)
+			{
+				case 2:
+					return new GeoCoordinate(coordinates[0], coordinates[1]);
+				case 3:
+					return new GeoCoordinate(coordinates[0], coordinates[1], coordinates[2]);
+			}
+
+			throw new ArgumentOutOfRangeException(
+				nameof(coordinates),
+				$"Cannot create a {nameof(GeoCoordinate)} from an array that does not contain 2 or 3 values");
 		}
 	}
 }

src/Nest/QueryDsl/Geo/Shape/GeoShapeBase.cs

@@ -24,8 +24,32 @@ public interface IGeoShape
 		bool? IgnoreUnmapped { get; set; }
 	}
 
+	internal enum GeoShapeFormat
+	{
+		GeoJson,
+		WellKnownText
+	}
+
+	internal static class GeoShapeType
+	{
+		public const string Point = "POINT";
+		public const string MultiPoint = "MULTIPOINT";
+		public const string LineString = "LINESTRING";
+		public const string MultiLineString = "MULTILINESTRING";
+		public const string Polygon = "POLYGON";
+		public const string MultiPolygon = "MULTIPOLYGON";
+		public const string Circle = "CIRCLE";
+		public const string Envelope = "ENVELOPE";
+		public const string GeometryCollection = "GEOMETRYCOLLECTION";
+
+		// WKT uses BBOX for envelope geo shape
+		public const string BoundingBox = "BBOX";
+	}
+
 	public abstract class GeoShapeBase : IGeoShape
 	{
+		internal GeoShapeFormat Format { get; set; }
+
 	    protected GeoShapeBase(string type) => this.Type = type;
 
 		/// <inheritdoc />
@@ -38,52 +62,121 @@ public abstract class GeoShapeBase : IGeoShape
 
 	internal class GeoShapeConverter : JsonConverter
 	{
-		public override bool CanWrite => false;
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+		{
+			if (value == null)
+			{
+				writer.WriteNull();
+				return;
+			}
 
-		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) =>
-			throw new NotSupportedException();
+			// IGeometryCollection needs to be handled separately because it does not
+			// implement IGeoShape, and can't because it would be a binary breaking change.
+			// Fixed in 7.x
+			if (value is IGeometryCollection collection)
+			{
+				if (collection is GeometryCollection geometryCollection && geometryCollection.Format == GeoShapeFormat.WellKnownText)
+				{
+					writer.WriteValue(GeoWKTWriter.Write(collection));
+					return;
+				}
+
+				writer.WriteStartObject();
+				writer.WritePropertyName("type");
+				writer.WriteValue(collection.Type);
+				writer.WritePropertyName("geometries");
+				serializer.Serialize(writer, collection.Geometries);
+				writer.WriteEndObject();
+			}
+			else if (value is IGeoShape shape)
+			{
+				if (value is GeoShapeBase shapeBase && shapeBase.Format == GeoShapeFormat.WellKnownText)
+				{
+					writer.WriteValue(GeoWKTWriter.Write(shapeBase));
+					return;
+				}
+
+				writer.WriteStartObject();
+				writer.WritePropertyName("type");
+				writer.WriteValue(shape.Type);
+				writer.WritePropertyName("coordinates");
+				switch (shape)
+				{
+					case IPointGeoShape point:
+						serializer.Serialize(writer, point.Coordinates);
+						break;
+					case IMultiPointGeoShape multiPoint:
+						serializer.Serialize(writer, multiPoint.Coordinates);
+						break;
+					case ILineStringGeoShape lineString:
+						serializer.Serialize(writer, lineString.Coordinates);
+						break;
+					case IMultiLineStringGeoShape multiLineString:
+						serializer.Serialize(writer, multiLineString.Coordinates);
+						break;
+					case IPolygonGeoShape polygon:
+						serializer.Serialize(writer, polygon.Coordinates);
+						break;
+					case IMultiPolygonGeoShape multiPolyon:
+						serializer.Serialize(writer, multiPolyon.Coordinates);
+						break;
+					case IEnvelopeGeoShape envelope:
+						serializer.Serialize(writer, envelope.Coordinates);
+						break;
+					case ICircleGeoShape circle:
+						serializer.Serialize(writer, circle.Coordinates);
+						writer.WritePropertyName("radius");
+						writer.WriteValue(circle.Radius);
+						break;
+				}
+				writer.WriteEndObject();
+			}
+		}
 
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
-			if (reader.TokenType == JsonToken.Null)
-				return null;
-
-			var shape = JObject.Load(reader);
-			return ReadJToken(shape, serializer);
+			switch (reader.TokenType)
+			{
+				case JsonToken.Null:
+					return null;
+				case JsonToken.String:
+					return GeoWKTReader.Read((string)reader.Value);
+				default:
+					var shape = JObject.Load(reader);
+					return ReadJToken(shape, serializer);
+			}
 		}
 
 		internal static object ReadJToken(JToken shape, JsonSerializer serializer)
 		{
-			var type = shape["type"];
-			var typeName = type?.Value<string>();
+			var typeName = shape["type"]?.Value<string>().ToUpperInvariant();
 			switch (typeName)
 			{
-				case "circle":
-					var radius = shape["radius"];
-					return ParseCircleGeoShape(shape, serializer, radius);
-				case "envelope":
+				case GeoShapeType.Circle:
+					return ParseCircleGeoShape(shape, serializer);
+				case GeoShapeType.Envelope:
 					return ParseEnvelopeGeoShape(shape, serializer);
-				case "linestring":
+				case GeoShapeType.LineString:
 					return ParseLineStringGeoShape(shape, serializer);
-				case "multilinestring":
+				case GeoShapeType.MultiLineString:
 					return ParseMultiLineStringGeoShape(shape, serializer);
-				case "point":
+				case GeoShapeType.Point:
 					return ParsePointGeoShape(shape, serializer);
-				case "multipoint":
+				case GeoShapeType.MultiPoint:
 					return ParseMultiPointGeoShape(shape, serializer);
-				case "polygon":
+				case GeoShapeType.Polygon:
 					return ParsePolygonGeoShape(shape, serializer);
-				case "multipolygon":
+				case GeoShapeType.MultiPolygon:
 					return ParseMultiPolygonGeoShape(shape, serializer);
-				case "geometrycollection":
+				case GeoShapeType.GeometryCollection:
 					return ParseGeometryCollection(shape, serializer);
 				default:
 					return null;
 			}
 		}
 
-		public override bool CanConvert(Type objectType) => typeof(IGeoShape).IsAssignableFrom(objectType) ||
-		                                                    typeof(IGeometryCollection).IsAssignableFrom(objectType);
+		public override bool CanConvert(Type objectType) =>
+			typeof(IGeoShape).IsAssignableFrom(objectType) || typeof(IGeometryCollection).IsAssignableFrom(objectType);
 
 		private static GeometryCollection ParseGeometryCollection(JToken shape, JsonSerializer serializer)
 		{
@@ -128,11 +221,11 @@ private static LineStringGeoShape ParseLineStringGeoShape(JToken shape, JsonSeri
 		private static EnvelopeGeoShape ParseEnvelopeGeoShape(JToken shape, JsonSerializer serializer) =>
 			new EnvelopeGeoShape {Coordinates = GetCoordinates<IEnumerable<GeoCoordinate>>(shape, serializer)};
 
-		private static CircleGeoShape ParseCircleGeoShape(JToken shape, JsonSerializer serializer, JToken radius) =>
+		private static CircleGeoShape ParseCircleGeoShape(JToken shape, JsonSerializer serializer) =>
 			new CircleGeoShape
 			{
 				Coordinates = GetCoordinates<GeoCoordinate>(shape, serializer),
-				Radius = radius?.Value<string>()
+				Radius = shape["radius"]?.Value<string>()
 			};
 
 		private static T GetCoordinates<T>(JToken shape, JsonSerializer serializer)

src/Nest/QueryDsl/Geo/Shape/GeoShapeQueryJsonConverter.cs

@@ -43,6 +43,7 @@ internal class GeoShapeQueryJsonConverter : JsonConverter
 		public override bool CanRead => true;
 		public override bool CanWrite => false;
 
+		// TODO: remove in 7.x
 		public virtual T GetCoordinates<T>(JToken shape, JsonSerializer serializer)
 		{
 			var coordinates = shape["coordinates"];
@@ -104,27 +105,27 @@ private static IGeoShapeQuery ParseIndexedShapeQuery(JToken indexedShape) =>
 		private static IGeoShapeQuery ParseShapeQuery(JToken shape, JsonSerializer serializer)
 		{
 			var type = shape["type"];
-			var typeName = type?.Value<string>();
+			var typeName = type?.Value<string>().ToUpperInvariant();
 			var geometry = GeoShapeConverter.ReadJToken(shape, serializer);
 			switch (typeName)
 			{
-				case "circle":
+				case GeoShapeType.Circle:
 					return new GeoShapeCircleQuery { Shape = geometry as ICircleGeoShape };
-				case "envelope":
+				case GeoShapeType.Envelope:
 					return new GeoShapeEnvelopeQuery { Shape = geometry as IEnvelopeGeoShape };
-				case "linestring":
+				case GeoShapeType.LineString:
 					return new GeoShapeLineStringQuery { Shape = geometry as ILineStringGeoShape };
-				case "multilinestring":
+				case GeoShapeType.MultiLineString:
 					return new GeoShapeMultiLineStringQuery { Shape = geometry as IMultiLineStringGeoShape };
-				case "point":
+				case GeoShapeType.Point:
 					return new GeoShapePointQuery { Shape = geometry as IPointGeoShape };
-				case "multipoint":
+				case GeoShapeType.MultiPoint:
 					return new GeoShapeMultiPointQuery { Shape = geometry as IMultiPointGeoShape };
-				case "polygon":
+				case GeoShapeType.Polygon:
 					return new GeoShapePolygonQuery { Shape = geometry as IPolygonGeoShape };
-				case "multipolygon":
+				case GeoShapeType.MultiPolygon:
 					return new GeoShapeMultiPolygonQuery { Shape = geometry as IMultiPolygonGeoShape };
-				case "geometrycollection":
+				case GeoShapeType.GeometryCollection:
 					return new GeoShapeGeometryCollectionQuery { Shape = geometry as IGeometryCollection };
 				default:
 					return null;

src/Nest/QueryDsl/Geo/Shape/GeometryCollection/GeometryCollection.cs

@@ -27,6 +27,8 @@ public interface IGeometryCollection
 	/// <inheritdoc cref="IGeometryCollection"/>
 	public class GeometryCollection : IGeometryCollection, IGeoShape
 	{
+		internal GeoShapeFormat Format { get; set; }
+
 		/// <inheritdoc />
 		public string Type => "geometrycollection";