Fix #1160: sort values on search failing round trip serialization

Author: gmarz

src/Nest/DSL/Search/SortGeoDistanceDescriptor.cs

@@ -19,6 +19,13 @@ public interface IGeoDistanceSort : ISort, ICustomJson
 
 	public class GeoDistanceSort : SortBase, IGeoDistanceSort
 	{
+		internal static List<string> Params = new List<string> { "missing", "mode", "order", "unit" };
+
+		internal static int MissingIndex = 0;
+		internal static int ModeIndex = 1;
+		internal static int OrderIndex = 2;
+		internal static int UnitIndex = 3;
+
 		public PropertyPathMarker Field { get; set; }
 		public string PinLocation { get; set; }
 		public IEnumerable<string> Points { get; set; }
@@ -30,10 +37,10 @@ object ICustomJson.GetCustomJson()
 			return new Dictionary<object, object>
 			{
 				{ this.Field, sort },
-				{ "missing", this.Missing },
-				{ "mode", this.Mode },
-				{ "order", this.Order },
-				{ "unit", this.GeoUnit }
+				{ Params[MissingIndex], this.Missing },
+				{ Params[ModeIndex], this.Mode},
+				{ Params[OrderIndex], this.Order },
+				{ Params[UnitIndex], this.GeoUnit }
 			};
 		}
 	}
@@ -119,10 +126,10 @@ object ICustomJson.GetCustomJson()
 			return new Dictionary<object, object>
 			{
 				{ Self.Field, sort },
-				{ "missing", Self.Missing },
-				{ "mode", Self.Mode},
-				{ "order", Self.Order },
-				{ "unit", Self.GeoUnit }
+				{ GeoDistanceSort.Params[GeoDistanceSort.MissingIndex], Self.Missing },
+				{ GeoDistanceSort.Params[GeoDistanceSort.ModeIndex], Self.Mode},
+				{ GeoDistanceSort.Params[GeoDistanceSort.OrderIndex], Self.Order },
+				{ GeoDistanceSort.Params[GeoDistanceSort.UnitIndex], Self.GeoUnit }
 			};
 		}
 	}

src/Nest/Resolvers/Converters/SortCollectionConverter.cs

@@ -1,4 +1,6 @@
-using Newtonsoft.Json;
+using Nest.DSL.Descriptors;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -13,14 +15,59 @@ public override bool CanConvert(Type objectType)
 			return typeof(IList<KeyValuePair<PropertyPathMarker, ISort>>).IsAssignableFrom(objectType);
 		}
 
-		public override bool CanRead
-		{
-			get { return false; }
-		}
-
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
-			return new InvalidOperationException();
+			var sorts = new List<KeyValuePair<PropertyPathMarker, ISort>>();
+			while (reader.TokenType != JsonToken.EndArray)
+			{
+				reader.Read();
+				if (reader.TokenType == JsonToken.EndArray)
+					break;
+				reader.Read();
+				var field = reader.Value as string;
+				reader.Read();
+
+				if (field == "_geo_distance")
+				{
+					var j = JObject.Load(reader);
+					if (j != null)
+					{
+						var sort = j.ToObject<GeoDistanceSort>(serializer);
+						if (sort != null)
+						{
+							LoadGeoDistanceSortLocation(sort, j);
+							sorts.Add(new KeyValuePair<PropertyPathMarker, ISort>("_geo_distance", sort));
+						}
+					}
+				}
+				else if (field == "_script")
+				{
+					var j = JObject.Load(reader);
+					if (j != null)
+					{
+						var sort = j.ToObject<ScriptSort>(serializer);
+						if (sort != null)
+						{
+							sorts.Add(new KeyValuePair<PropertyPathMarker, ISort>("_script", sort));
+						}
+					}
+				}
+				else
+				{
+					var j = JObject.Load(reader);
+					if (j != null)
+					{
+						var sort = j.ToObject<Sort>(serializer);
+						if (sort != null)
+						{
+							sort.Field = field;
+							sorts.Add(new KeyValuePair<PropertyPathMarker, ISort>(sort.Field, sort));
+						}
+					}
+				}
+				reader.Read();
+			}
+			return sorts;
 		}
 
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
@@ -38,5 +85,27 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 			}
 			writer.WriteEndArray();
 		}
+
+		private void LoadGeoDistanceSortLocation(GeoDistanceSort sort, JObject j)
+		{
+			var field = j.Properties().Where(p => !GeoDistanceSort.Params.Contains(p.Name)).FirstOrDefault();
+
+			if (field != null)
+			{
+				sort.Field = field.Name;
+
+				try
+				{
+					sort.PinLocation = field.Value.Value<string>();
+				}
+				catch { }
+
+				try
+				{
+					sort.Points = field.Value.Value<IEnumerable<string>>();
+				}
+				catch { }
+			}
+		}
 	}
 }

src/Tests/Nest.Tests.Unit/Search/Sorting/SortTests.cs

@@ -1,6 +1,9 @@
-using System.Reflection;
+using FluentAssertions;
+using System.Reflection;
 using NUnit.Framework;
 using Nest.Tests.MockData.Domain;
+using System.Text;
+using System.IO;
 
 namespace Nest.Tests.Unit.Search.Sorting
 {
@@ -439,5 +442,39 @@ public void RandomScriptSort()
 			);
 			this.JsonEquals(s, MethodInfo.GetCurrentMethod());
 		}
+
+		[Test]
+		public void SortSerializeThenDeserializeTest()
+		{
+			var d1 = new SearchDescriptor<ElasticsearchProject>()
+				.From(0)
+				.Size(20)
+				.MatchAll()
+				.Sort(s => s
+					.OnField(p => p.Id)
+					.Order(SortOrder.Ascending)
+				)
+				.SortGeoDistance(s => s
+					.OnField(p => p.Origin)
+					.PinTo(40, 70)
+				)
+				.SortScript(s => s
+					.Ascending()
+					.Script("(doc['_id'].stringValue + salt).hashCode()")
+					.Params(p => p
+						.Add("salt", "some_random_string")
+					)
+					.Type("number")
+				);
+
+			var s1 = this._client.Serializer.Serialize(d1);
+			var d2 = this._client.Serializer.Deserialize<SearchDescriptor<ElasticsearchProject>>(new MemoryStream(s1));
+			var s2 = this._client.Serializer.Serialize(d2);
+
+			var s1Json = Encoding.UTF8.GetString(s1);
+			var s2Json = Encoding.UTF8.GetString(s2);
+
+			s1Json.JsonEquals(s2Json).Should().BeTrue();
+		}
 	}
 }