Updated JsonNetSerializer implementation, so that its default contract resolver is aware of connection settings and its config

Author: Mpdreamz

src/Elasticsearch.Net/Connection/HttpConnection.cs

@@ -60,7 +60,7 @@ protected virtual HttpWebRequest CreateWebRequest(RequestData requestData)
 			request.Accept = requestData.Accept;
 			request.ContentType = requestData.ContentType;
 			request.MaximumResponseHeadersLength = -1;
-			request.AllowWriteStreamBuffering = false;
+			//request.AllowWriteStreamBuffering = false;
 			request.Pipelined = requestData.Pipelined;
 
 			if (requestData.HttpCompression)

src/Nest/CommonAbstractions/ConnectionSettings/ConnectionSettingsBase.cs

@@ -14,7 +14,7 @@ namespace Nest
 	/// </summary>
 	public class ConnectionSettings : ConnectionSettingsBase<ConnectionSettings>
 	{
-		public delegate IElasticsearchSerializer SourceSerializerFactory(IConnectionSettingsValues values, IElasticsearchSerializer builtIn);
+		public delegate IElasticsearchSerializer SourceSerializerFactory(IElasticsearchSerializer builtIn, IConnectionSettingsValues values);
 
 		public ConnectionSettings(Uri uri = null)
 			: this(new SingleNodeConnectionPool(uri ?? new Uri("http://localhost:9200"))) { }
@@ -89,7 +89,7 @@ IPropertyMappingProvider propertyMappingProvider
 			: base(connectionPool, connection, null)
 		{
 			var defaultSerializer = new JsonNetSerializer(this);
-			this._sourceSerializer = sourceSerializerFactory?.Invoke(this, defaultSerializer) ?? defaultSerializer;
+			this._sourceSerializer = sourceSerializerFactory?.Invoke(defaultSerializer, this) ?? defaultSerializer;
 			this.UseThisRequestResponseSerializer = defaultSerializer;
 			this._propertyMappingProvider = propertyMappingProvider ?? new PropertyMappingProvider();
 
@@ -212,7 +212,7 @@ private void ApplyPropertyMappings<TDocument>(IList<IClrTypePropertyMapping<TDoc
 						throw new ArgumentException($"Property mapping '{e}' on type {typeName} can not be ignored it already has a mapping to '{mappedAs}'");
 					throw new ArgumentException($"Property mapping '{e}' on type {typeName} can not be mapped to '{newName}' already mapped as '{mappedAs}'");
 				}
-				_propertyMappings.Add(memberInfo, mapping.ToPropertyMapping());
+				_propertyMappings[memberInfo] = mapping.ToPropertyMapping();
 			}
 		}
 

src/Nest/CommonAbstractions/SerializationBehavior/ElasticContractResolver.cs

@@ -50,12 +50,10 @@ protected override JsonContract CreateContract(Type objectType)
 					contract.Converter = new QueryContainerCollectionJsonConverter();
 				else if (o == typeof(ServerError))
 					contract.Converter = new ServerErrorJsonConverter();
-				else if (o == typeof(DateTime) ||
-						 o == typeof(DateTime?))
+				else if (o == typeof(DateTime) || o == typeof(DateTime?))
 					contract.Converter = new IsoDateTimeConverter { Culture = CultureInfo.InvariantCulture };
-				else if (o == typeof(TimeSpan) ||
-						 o == typeof(TimeSpan?))
-					contract.Converter = new TimeSpanConverter();
+				else if (o == typeof(TimeSpan) || o == typeof(TimeSpan?))
+					contract.Converter = new TimeSpanToStringConverter();
 
 				ApplyBuildInSerializersForType(o, contract);
 

src/Nest/CommonAbstractions/SerializationBehavior/GenericJsonConverters/ServerErrorJsonConverter.cs

@@ -6,19 +6,18 @@
 namespace Nest
 {
 	internal class ServerErrorJsonConverter : JsonConverter
-	{
+	{
 		public override bool CanRead => true;
 		public override bool CanWrite => false;
 		public override bool CanConvert(Type objectType) => objectType == typeof(ServerError);
 
-		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { }
-
-		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-		{
-			var token = JToken.Load(reader);
-			ServerError error = null;
-			token.TryParseServerError(serializer, out error);
-			return error;
-		}
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { }
+
+		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+		{
+			var token = JToken.Load(reader);
+			token.TryParseServerError(serializer, out var error);
+			return error;
+		}
 	}
-}
+}

src/Nest/CommonAbstractions/SerializationBehavior/GenericJsonConverters/TimeSpanConverter.cs renamed to src/Nest/CommonAbstractions/SerializationBehavior/GenericJsonConverters/TimeSpanToStringConverter.cs

@@ -1,13 +1,9 @@
 using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Reflection;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 
 namespace Nest
 {
-	internal class TimeSpanConverter : JsonConverter
+	internal class TimeSpanToStringConverter : JsonConverter
 	{
 		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 		{
@@ -22,22 +18,12 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
-			if (reader.TokenType == JsonToken.Null)
+			switch (reader.TokenType)
 			{
-				if (!objectType.IsGeneric() || objectType.GetGenericTypeDefinition() != typeof (Nullable<>))
-					throw new JsonSerializationException($"Cannot convert null value to {objectType}.");
-
-				return null;
-			}
-			if (reader.TokenType == JsonToken.String)
-			{
-				return TimeSpan.Parse((string) reader.Value);
+				case JsonToken.Null: return null;
+				case JsonToken.String: return TimeSpan.Parse((string) reader.Value);
+				case JsonToken.Integer: return new TimeSpan((long) reader.Value);
 			}
-			if (reader.TokenType == JsonToken.Integer)
-			{
-				return new TimeSpan((long) reader.Value);
-			}
-
 			throw new JsonSerializationException($"Cannot convert token of type {reader.TokenType} to {objectType}.");
 		}
 

src/Serializers/Nest.JsonNetSerializer/ConnectionSettingsAwareContractResolver.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace Nest.JsonNetSerializer
+{
+	public class ConnectionSettingsAwareContractResolver : DefaultContractResolver
+	{
+		private readonly IConnectionSettingsValues _connectionSettings;
+
+		public ConnectionSettingsAwareContractResolver(IConnectionSettingsValues connectionSettings)
+		{
+			_connectionSettings = connectionSettings ?? throw new ArgumentNullException(nameof(connectionSettings));
+		}
+
+		protected override string ResolvePropertyName(string fieldName) =>
+			this._connectionSettings.DefaultFieldNameInferrer != null
+				? this._connectionSettings.DefaultFieldNameInferrer(fieldName)
+				: base.ResolvePropertyName(fieldName);
+
+		protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
+		{
+			var property = base.CreateProperty(member, memberSerialization);
+			ApplyShouldSerializer(property);
+			ApplyPropertyOverrides(member, property);
+			return property;
+		}
+
+		/// <summary> Renames/Ignores a property based on the connection settings mapping or custom attributes for the property </summary>
+		private void ApplyPropertyOverrides(MemberInfo member, JsonProperty property)
+		{
+			if (!this._connectionSettings.PropertyMappings.TryGetValue(member, out var propertyMapping))
+				propertyMapping = ElasticsearchPropertyAttributeBase.From(member);
+
+			var serializerMapping = this._connectionSettings.PropertyMappingProvider?.CreatePropertyMapping(member);
+
+			var nameOverride = propertyMapping?.Name ?? serializerMapping?.Name;
+			if (!string.IsNullOrWhiteSpace(nameOverride)) property.PropertyName = nameOverride;
+
+			var overrideIgnore = propertyMapping?.Ignore ?? serializerMapping?.Ignore;
+			if (overrideIgnore.HasValue)
+				property.Ignored = overrideIgnore.Value;
+		}
+
+		private static void ApplyShouldSerializer(JsonProperty property)
+		{
+			if (property.PropertyType == typeof(QueryContainer))
+				property.ShouldSerialize = o => ShouldSerializeQueryContainer(o, property);
+			else if (property.PropertyType == typeof(IEnumerable<QueryContainer>))
+				property.ShouldSerialize = o => ShouldSerializeQueryContainers(o, property);
+		}
+
+		private static bool ShouldSerializeQueryContainer(object o, JsonProperty prop)
+		{
+			if (o == null) return false;
+			if (!(prop.ValueProvider.GetValue(o) is QueryContainer q)) return false;
+			if (((IQueryContainer)q).IsWritable) return true;
+			var nq = q as NoMatchQueryContainer;
+			return nq?.Shortcut != null;
+		}
+
+		private static bool ShouldSerializeQueryContainers(object o, JsonProperty prop)
+		{
+			if (o == null) return false;
+			if (!(prop.ValueProvider.GetValue(o) is IEnumerable<QueryContainer> q)) return false;
+			var queryContainers = q as QueryContainer[] ?? q.ToArray();
+			return queryContainers.Any(qq=>qq != null && ((IQueryContainer)qq).IsWritable);
+		}
+
+	}
+}

src/Serializers/Nest.JsonNetSerializer/JsonNetSourceSerializerBase.cs renamed to src/Serializers/Nest.JsonNetSerializer/ConnectionSettingsAwareSerializerBase.Customization.cs

@@ -1,51 +1,22 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Elasticsearch.Net;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Serialization;
 
 namespace Nest.JsonNetSerializer
 {
-	public abstract class JsonNetSourceSerializerBase : IElasticsearchSerializer
+	public abstract partial class ConnectionSettingsAwareSerializerBase : IElasticsearchSerializer
 	{
-		protected IElasticsearchSerializer BuiltinSerializer { get; }
 		private static readonly Encoding ExpectedEncoding = new UTF8Encoding(false);
 		protected virtual int BufferSize => 1024;
 
 		private readonly JsonSerializer _serializer;
 		private readonly JsonSerializer _collapsedSerializer;
 
-		protected JsonNetSourceSerializerBase(IElasticsearchSerializer builtinSerializer)
-		{
-			BuiltinSerializer = builtinSerializer;
-			_serializer = CreateSerializer(SerializationFormatting.Indented);
-			_collapsedSerializer = CreateSerializer(SerializationFormatting.None);
-		}
-
-		protected abstract JsonSerializerSettings CreateJsonSerializerSettings();
-		protected abstract IEnumerable<JsonConverter> CreateJsonConverters();
-		protected virtual IContractResolver CreateContractResolver() => new DefaultContractResolver();
-
-		private JsonSerializer CreateSerializer(SerializationFormatting formatting)
-		{
-			var s = CreateJsonSerializerSettings();
-			var converters = CreateJsonConverters() ?? Enumerable.Empty<JsonConverter>();
-			var contract = CreateContractResolver();
-			s.Formatting = formatting == SerializationFormatting.Indented ? Formatting.Indented : Formatting.None;
-			s.ContractResolver = contract;
-			s.Converters = converters.Concat(new List<JsonConverter>
-			{
-				new RevertBackToBuiltinSerializer(BuiltinSerializer)
-			}).ToList();
-			return JsonSerializer.Create(s);
-		}
-
 		public T Deserialize<T>(Stream stream)
 		{
 			using (var streamReader = new StreamReader(stream))

src/Serializers/Nest.JsonNetSerializer/ConnectionSettingsAwareSerializerBase.Serializer.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using Nest.JsonNetSerializer.Converters;
+
+namespace Nest.JsonNetSerializer
+{
+	public abstract partial class ConnectionSettingsAwareSerializerBase
+	{
+		protected IConnectionSettingsValues ConnectionSettings { get; }
+		protected IElasticsearchSerializer BuiltinSerializer { get; }
+
+		private List<JsonConverter> Converters { get; }
+
+		protected ConnectionSettingsAwareSerializerBase(
+			IElasticsearchSerializer builtinSerializer,
+			IConnectionSettingsValues connectionSettings)
+		{
+			ConnectionSettings = connectionSettings;
+			BuiltinSerializer = builtinSerializer;
+			this.Converters = new List<JsonConverter>
+			{
+				new RevertBackToBuiltinSerializer(BuiltinSerializer),
+				new TimeSpanToStringConverter()
+			};
+			_serializer = CreateSerializer(SerializationFormatting.Indented);
+			_collapsedSerializer = CreateSerializer(SerializationFormatting.None);
+
+		}
+
+		private JsonSerializer CreateSerializer(SerializationFormatting formatting)
+		{
+			var s = CreateJsonSerializerSettings();
+			var converters = CreateJsonConverters() ?? Enumerable.Empty<JsonConverter>();
+			var contract = CreateContractResolver();
+			s.Formatting = formatting == SerializationFormatting.Indented ? Formatting.Indented : Formatting.None;
+			s.ContractResolver = contract;
+			s.Converters = converters.Concat(this.Converters).ToList();
+			return JsonSerializer.Create(s);
+		}
+		private IContractResolver CreateContractResolver()
+		{
+			var contract = new ConnectionSettingsAwareContractResolver(this.ConnectionSettings);
+			ModifyContractResolver(contract);
+			return contract;
+		}
+
+		protected abstract JsonSerializerSettings CreateJsonSerializerSettings();
+
+		protected abstract IEnumerable<JsonConverter> CreateJsonConverters();
+
+		protected virtual void ModifyContractResolver(ConnectionSettingsAwareContractResolver resolver) { }
+	}
+
+	public class JsonNetSerializer : ConnectionSettingsAwareSerializerBase
+	{
+		private readonly Func<JsonSerializerSettings> _jsonSerializerSettingsFactory;
+		private readonly Action<ConnectionSettingsAwareContractResolver> _modifyContractResolver;
+		private readonly IEnumerable<JsonConverter> _contractJsonConverters;
+
+		public static IElasticsearchSerializer Default(IElasticsearchSerializer builtin, IConnectionSettingsValues values)
+			=> new JsonNetSerializer(builtin, values);
+
+		public JsonNetSerializer(
+			IElasticsearchSerializer builtinSerializer,
+			IConnectionSettingsValues connectionSettings,
+			Func<JsonSerializerSettings> jsonSerializerSettingsFactory = null,
+			Action<ConnectionSettingsAwareContractResolver> modifyContractResolver = null,
+			IEnumerable<JsonConverter> contractJsonConverters = null)
+			: base(builtinSerializer, connectionSettings)
+		{
+			_jsonSerializerSettingsFactory = jsonSerializerSettingsFactory;
+			_modifyContractResolver = modifyContractResolver;
+			_contractJsonConverters = contractJsonConverters ?? Enumerable.Empty<JsonConverter>();
+		}
+
+		protected override JsonSerializerSettings CreateJsonSerializerSettings() => _jsonSerializerSettingsFactory?.Invoke();
+
+		protected override IEnumerable<JsonConverter> CreateJsonConverters() => _contractJsonConverters;
+
+		protected override void ModifyContractResolver(ConnectionSettingsAwareContractResolver resolver) =>
+			_modifyContractResolver?.Invoke(resolver);
+
+	}
+}

src/Serializers/Nest.JsonNetSerializer/RevertBackToBuiltinSerializer.cs renamed to src/Serializers/Nest.JsonNetSerializer/Converters/RevertBackToBuiltinSerializer.cs

@@ -6,7 +6,7 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace Nest.JsonNetSerializer
+namespace Nest.JsonNetSerializer.Converters
 {
 	internal class RevertBackToBuiltinSerializer : JsonConverter
 	{
@@ -41,6 +41,5 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 		};
 
 		public override bool CanConvert(Type objectType) => NestTypesThatCanAppearInSource.Contains(objectType);
-
 	}
 }

src/Serializers/Nest.JsonNetSerializer/Converters/TimeSpanToStringConverter.cs

@@ -0,0 +1,35 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest.JsonNetSerializer.Converters
+{
+	/// <summary>
+	/// Included for compatibility reasons
+	/// </summary>
+	internal class TimeSpanToStringConverter : JsonConverter
+	{
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+		{
+			if (value == null)
+				writer.WriteNull();
+			else
+			{
+				var timeSpan = (TimeSpan) value;
+				writer.WriteValue(timeSpan.Ticks);
+			}
+		}
+
+		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+		{
+			switch (reader.TokenType)
+			{
+				case JsonToken.Null: return null;
+				case JsonToken.String: return TimeSpan.Parse((string) reader.Value);
+				case JsonToken.Integer: return new TimeSpan((long) reader.Value);
+			}
+			throw new JsonSerializationException($"Cannot convert token of type {reader.TokenType} to {objectType}.");
+		}
+
+		public override bool CanConvert(Type objectType) => objectType == typeof (TimeSpan) || objectType == typeof (TimeSpan?);
+	}
+}