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

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

@@ -16,11 +16,34 @@ public interface IGeoShape
 		string Type { get; }
 	}
 
+	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";
+	}
+
 	/// <summary>
 	/// Base type for geo shapes
 	/// </summary>
 	public abstract class GeoShapeBase : IGeoShape
 	{
+		internal GeoShapeFormat Format { get; set; }
 	    protected GeoShapeBase(string type) => this.Type = type;
 
 		/// <inheritdoc />
@@ -29,42 +52,112 @@ 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();
+			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);
+
+				switch (shape)
+				{
+					case IPointGeoShape point:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, point.Coordinates);
+						break;
+					case IMultiPointGeoShape multiPoint:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, multiPoint.Coordinates);
+						break;
+					case ILineStringGeoShape lineString:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, lineString.Coordinates);
+						break;
+					case IMultiLineStringGeoShape multiLineString:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, multiLineString.Coordinates);
+						break;
+					case IPolygonGeoShape polygon:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, polygon.Coordinates);
+						break;
+					case IMultiPolygonGeoShape multiPolygon:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, multiPolygon.Coordinates);
+						break;
+					case IEnvelopeGeoShape envelope:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, envelope.Coordinates);
+						break;
+					case ICircleGeoShape circle:
+						writer.WritePropertyName("coordinates");
+						serializer.Serialize(writer, circle.Coordinates);
+						writer.WritePropertyName("radius");
+						writer.WriteValue(circle.Radius);
+						break;
+					case IGeometryCollection collection:
+						writer.WritePropertyName("geometries");
+						serializer.Serialize(writer, collection.Geometries);
+						break;
+				}
+
+				writer.WriteEndObject();
+			}
+			else
+			{
+				throw new NotSupportedException($"{value.GetType()} is not a supported {nameof(IGeoShape)}");
+			}
+		}
 
 		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 IGeoShape ReadJToken(JToken shape, JsonSerializer serializer)
 		{
-			var typeName = shape["type"]?.Value<string>();
+			var typeName = shape["type"]?.Value<string>().ToUpperInvariant();
 			switch (typeName)
 			{
-				case "circle":
+				case GeoShapeType.Circle:
 					return ParseCircleGeoShape(shape, serializer);
-				case "envelope":
+				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;

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

@@ -95,7 +95,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 		}
 
 		private static IGeoShapeQuery ParseIndexedShapeQuery(JToken indexedShape) =>
-			new GeoShapeQuery { IndexedShape = indexedShape.ToObject<FieldLookup>()};
+			new GeoShapeQuery { IndexedShape = indexedShape.ToObject<FieldLookup>() };
 
 		private static IGeoShapeQuery ParseShapeQuery(JToken shape, JsonSerializer serializer)
 		{

src/Nest/QueryDsl/Geo/WKT/GeoWKTException.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Nest
+{
+	/// <summary>
+	/// An exception when handling <see cref="IGeoShape"/> in Well-Known Text format
+	/// </summary>
+	public class GeoWKTException : Exception
+	{
+		public GeoWKTException(string message)
+			: base(message)
+		{
+		}
+
+		public GeoWKTException(string message, int lineNumber, int position)
+			: base($"{message} at line {lineNumber}, position {position}")
+		{
+		}
+	}
+}