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

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
+		internal 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.
+			// This is fixed in next major release.
+			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";