public void Serialize_EqualAndNotEqual_ShouldHaveCorrectPath()
 {
     NestSerializer
     .Serialize <TestData>(data => data.StringProperty == "Test" && data.LongProperty != 42)
     .Should()
     .BeValidJson()
     .And
     .ContainInOrder("query", "bool", "must", "bool", "must", "term", "StringProperty", "Test", "must_not", "term", "LongProperty", "42");
 }
 public void Serialize_Equal_ShouldHaveCorrectPath()
 {
     NestSerializer
     .Serialize <TestData>(data => data.StringProperty == "Test")
     .Should()
     .BeValidJson()
     .And
     .ContainInOrder("term", "StringProperty", "Test");
 }
 public void Serialize_GetInnerProperty_ShouldHaveCorrectPath()
 {
     NestSerializer
     .Serialize <TestData>(data => data.Inner.Inner.BoolProperty)
     .Should()
     .BeValidJson()
     .And
     .ContainInOrder("term", "Inner.Inner.BoolProperty");
 }
 public void Serialize_GetBoolProperty_ShouldHaveCorrectPath()
 {
     NestSerializer
     .Serialize <TestData>(data => data.BoolProperty)
     .Should()
     .BeValidJson()
     .And
     .ContainInOrder("query", "bool", "must", "term", "BoolProperty");
 }
Example #5
0
        /// <summary>
        /// internal constructor by TypeMappingWriter itself when it recurses, passes seenTypes as safeguard agains maxRecursion
        /// </summary>
        internal TypeMappingWriter(Type t, string typeName, IConnectionSettingsValues connectionSettings, int maxRecursion, ConcurrentDictionary <Type, int> seenTypes)
        {
            this._type = GetUnderlyingType(t);
            this._connectionSettings = connectionSettings;

            this.TypeName     = typeName;
            this.MaxRecursion = maxRecursion;
            this.SeenTypes    = seenTypes;

            this._elasticSerializer = new NestSerializer(this._connectionSettings);
            this.Infer = new ElasticInferrer(this._connectionSettings);
        }
        /// <summary>
        /// internal constructor by TypeMappingWriter itself when it recurses, passes seenTypes as safeguard agains maxRecursion
        /// </summary>
        internal TypeMappingWriter(Type t, string typeName, IConnectionSettingsValues connectionSettings, int maxRecursion, ConcurrentDictionary<Type, int> seenTypes)
        {
            this._type = GetUnderlyingType(t);
            this._connectionSettings = connectionSettings;

            this.TypeName = typeName;
            this.MaxRecursion = maxRecursion;
            this.SeenTypes = seenTypes;

            this._elasticSerializer = new NestSerializer(this._connectionSettings);
            this.Infer = new ElasticInferrer(this._connectionSettings);
        }
Example #7
0
		public static IElasticClient GetFixedReturnClient(object responseJson)
		{
			var serializer = new NestSerializer(new ConnectionSettings());
			byte[] fixedResult;
			using (var ms = new MemoryStream())
			{
				serializer.Serialize(responseJson, ms);
				fixedResult = ms.ToArray();
			}
			var connection = new InMemoryConnection(fixedResult);
			var connectionPool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
			var settings = new ConnectionSettings(connectionPool, connection);
			return new ElasticClient(settings);
		}
Example #8
0
        public TypeMappingWriter(Type t, TypeNameMarker typeName, IConnectionSettingsValues connectionSettings, int maxRecursion)
        {
            this._type = t;
            this._connectionSettings = connectionSettings;

            this.TypeName     = typeName;
            this.MaxRecursion = maxRecursion;

            this.SeenTypes = new ConcurrentDictionary <Type, int>();
            this.SeenTypes.TryAdd(t, 0);

            this._elasticSerializer = new NestSerializer(this._connectionSettings);
            this.Infer = new ElasticInferrer(this._connectionSettings);
        }
        public TypeMappingWriter(Type t, TypeNameMarker typeName, IConnectionSettingsValues connectionSettings, int maxRecursion)
        {
            this._type = t;
            this._connectionSettings = connectionSettings;

            this.TypeName = typeName;
            this.MaxRecursion = maxRecursion;

            this.SeenTypes = new ConcurrentDictionary<Type, int>();
            this.SeenTypes.TryAdd(t, 0);

            this._elasticSerializer = new NestSerializer(this._connectionSettings);
            this.Infer = new ElasticInferrer(this._connectionSettings);
        }
		/// <inheritdoc />
		public Task<IMultiSearchResponse> MultiSearchAsync(IMultiSearchRequest request)
		{
			return this.Dispatcher.DispatchAsync<IMultiSearchRequest, MultiSearchRequestParameters, MultiSearchResponse, IMultiSearchResponse>(
				request,
				(p, d) =>
				{
					var converter = CreateMultiSearchDeserializer(p);
					var serializer = new NestSerializer(this.ConnectionSettings, converter);
					var json = serializer.SerializeToBytes(p).Utf8String();
					var creator = new MultiSearchCreator((r, s) => serializer.Deserialize<MultiSearchResponse>(s));
					request.RequestParameters.DeserializationOverride(creator);
					return this.LowLevelDispatch.MsearchDispatchAsync<MultiSearchResponse>(p, json);
				}
			);
		}
        public void SerializationTest()
        {
            const string Test = nameof(Test);
            Expression <Func <TestData, bool> > exp = data => data.StringProperty == "Test" && data.LongProperty == 42;

            var result = NestSerializer.Serialize(exp);

            //Console.Out.WriteLine(NestSerializer.Probe(exp));
            //Console.Out.WriteLine("==Result==");
            Console.Out.WriteLine(result);

            result
            .Should()
            .NotBeNullOrEmpty();
        }
Example #12
0
        public static IElasticClient GetFixedReturnClient(object responseJson)
        {
            var serializer = new NestSerializer(new ConnectionSettings());

            byte[] fixedResult;
            using (var ms = new MemoryStream())
            {
                serializer.Serialize(responseJson, ms);
                fixedResult = ms.ToArray();
            }
            var connection     = new InMemoryConnection(fixedResult);
            var connectionPool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
            var settings       = new ConnectionSettings(connectionPool, connection);

            return(new ElasticClient(settings));
        }
Example #13
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (this._settings == null)
            {
                var elasticContractResolver = serializer.ContractResolver as ElasticContractResolver;
                if (elasticContractResolver == null)
                {
                    return new MultiSearchResponse {
                               IsValid = false
                    }
                }
                ;
                var piggyBackState = elasticContractResolver.PiggyBackState;
                if (piggyBackState == null || piggyBackState.ActualJsonConverter == null)
                {
                    return new MultiSearchResponse {
                               IsValid = false
                    }
                }
                ;

                var realConverter = piggyBackState.ActualJsonConverter as MultiSearchConverter;
                if (realConverter == null)
                {
                    return new MultiSearchResponse {
                               IsValid = false
                    }
                }
                ;

                var mr = realConverter.ReadJson(reader, objectType, existingValue, serializer) as MultiSearchResponse;
                return(mr);
            }


            var response   = new MultiSearchResponse();
            var jsonObject = JObject.Load(reader);

            var docsJarray = (JArray)jsonObject["responses"];

            if (docsJarray == null)
            {
                return(response);
            }
            var multiSearchDescriptor = this._descriptor;

            if (this._descriptor == null)
            {
                return(multiSearchDescriptor);
            }

            var withMeta = docsJarray.Zip(this._descriptor._Operations, (doc, desc) => new MultiHitTuple {
                Hit = doc, Descriptor = desc
            });
            var originalResolver = serializer.ContractResolver;

            foreach (var m in withMeta)
            {
                var descriptor           = m.Descriptor.Value;
                var concreteTypeSelector = descriptor._ConcreteTypeSelector;
                var baseType             = m.Descriptor.Value._ClrType;
                var types = m.Descriptor.Value._Types.EmptyIfNull().ToList();

                //if we dont already have a concrete type converter but we have selected more types then
                //just the base return type automagically create our own concrete type converter
                if (concreteTypeSelector == null &&
                    types.HasAny() &&
                    types.Count() > types.Count(x => x.Type == baseType))
                {
                    var inferrer = new ElasticInferrer(this._settings);

                    var typeDict = types.ToDictionary(inferrer.TypeName, t => t.Type);
                    concreteTypeSelector = (o, h) =>
                    {
                        Type t;
                        return(!typeDict.TryGetValue(h.Type, out t) ? baseType : t);
                    };
                }
                var generic = MakeDelegateMethodInfo.MakeGenericMethod(baseType);

                if (concreteTypeSelector != null)
                {
                    var elasticSerializer = new NestSerializer(this._settings);
                    var state             = typeof(ConcreteTypeConverter <>).CreateGenericInstance(baseType, concreteTypeSelector) as JsonConverter;
                    if (state != null)
                    {
                        var settings = elasticSerializer.CreateSettings(piggyBackJsonConverter: state);

                        var jsonSerializer = new JsonSerializer()
                        {
                            NullValueHandling    = settings.NullValueHandling,
                            DefaultValueHandling = settings.DefaultValueHandling,
                            ContractResolver     = settings.ContractResolver,
                        };
                        foreach (var converter in settings.Converters.EmptyIfNull())
                        {
                            jsonSerializer.Converters.Add(converter);
                        }
                        generic.Invoke(null, new object[] { m, jsonSerializer, response._Responses, this._settings });
                        continue;
                    }
                }
                generic.Invoke(null, new object[] { m, serializer, response._Responses, this._settings });
            }

            return(response);
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (this._settings == null)
            {
                var elasticContractResolver = serializer.ContractResolver as ElasticContractResolver;
                if (elasticContractResolver == null)
                {
                    return new MultiSearchResponse {
                               IsValid = false
                    }
                }
                ;
                var piggyBackState = elasticContractResolver.PiggyBackState;
                if (piggyBackState == null || piggyBackState.ActualJsonConverter == null)
                {
                    return new MultiSearchResponse {
                               IsValid = false
                    }
                }
                ;

                var realConverter = piggyBackState.ActualJsonConverter as MultiSearchConverter;
                if (realConverter == null)
                {
                    return new MultiSearchResponse {
                               IsValid = false
                    }
                }
                ;

                var mr = realConverter.ReadJson(reader, objectType, existingValue, serializer) as MultiSearchResponse;
                return(mr);
            }


            var response   = new MultiSearchResponse();
            var jsonObject = JObject.Load(reader);

            var docsJarray = (JArray)jsonObject["responses"];

            if (docsJarray == null)
            {
                return(response);
            }
            var multiSearchDescriptor = this._descriptor;

            if (this._descriptor == null)
            {
                return(multiSearchDescriptor);
            }

            var withMeta = docsJarray.Zip(this._descriptor._Operations, (doc, desc) => new MultiHitTuple {
                Hit = doc, Descriptor = desc
            });
            var originalResolver = serializer.ContractResolver;

            foreach (var m in withMeta)
            {
                var descriptor           = m.Descriptor.Value;
                var concreteTypeSelector = descriptor.TypeSelector;
                var baseType             = m.Descriptor.Value._ClrType;

                var generic = MakeDelegateMethodInfo.MakeGenericMethod(baseType);

                if (concreteTypeSelector != null)
                {
                    var elasticSerializer = new NestSerializer(this._settings);

                    var state = typeof(ConcreteTypeConverter <>).CreateGenericInstance(baseType, concreteTypeSelector) as JsonConverter;
                    if (state != null)
                    {
                        var settings = elasticSerializer.CreateSettings(piggyBackJsonConverter: state);

                        var jsonSerializer = new JsonSerializer()
                        {
                            NullValueHandling    = settings.NullValueHandling,
                            DefaultValueHandling = settings.DefaultValueHandling,
                            ContractResolver     = settings.ContractResolver,
                        };
                        foreach (var converter in settings.Converters.EmptyIfNull())
                        {
                            jsonSerializer.Converters.Add(converter);
                        }
                        generic.Invoke(null, new object[] { m, jsonSerializer, response._Responses, this._settings });
                        continue;
                    }
                }
                generic.Invoke(null, new object[] { m, serializer, response._Responses, this._settings });
            }

            return(response);
        }
            private ISearchResponse <Person> DeserialiseSearchResponse()
            {
                var serializer = new NestSerializer(new ConnectionSettings());

                return(serializer.Deserialize <SearchResponse <Person> >(_stream));
            }