WriteStartObject() public method

Writes the beginning of a JSON object.
public WriteStartObject ( ) : void
return void
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var representation = value as Representation;
            if (representation != null)
                representation.RepopulateHyperMedia();

            var list = (IRepresentationList)value;

            writer.WriteStartObject();
            writer.WritePropertyName("_links");
            serializer.Serialize(writer, list.Links);

            writer.WritePropertyName("_embedded");
            writer.WriteStartObject();
            writer.WritePropertyName(list.Rel);
            writer.WriteStartArray();
            foreach (Representation halResource in list)
            {
                serializer.Serialize(writer, halResource);
            }

            writer.WriteEndArray();
            writer.WriteEndObject();

            var listType = list.GetType();
            var propertyInfos = typeof(RepresentationList<>).GetProperties().Select(p => p.Name);
            foreach (var property in listType.GetProperties().Where(p => !propertyInfos.Contains(p.Name)))
            {
                writer.WritePropertyName(property.Name.ToLower());
                serializer.Serialize(writer, property.GetValue(value, null));
            }

            writer.WriteEndObject();
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var request = value as UpdateListItemsRequest;
            if (request == null)
            {
                writer.WriteNull();
                return;
            }
            /*
             "additems" : ["3","4","5"],
            "adduniqueitems" : ["1","6"],
            "removeitems": ["2","5"]
             */
            writer.WriteStartObject();
            writer.WritePropertyName(request.Property );
            writer.WriteStartObject();
            if (request.ItemsToAdd.Count > 0)
            {
                if (request.AddUniquely == true)
                    writer.WriteArray("adduniqueitems", request.ItemsToAdd);
                else
                    writer.WriteArray("additems", request.ItemsToAdd);
            }
            if (request.ItemsToRemove.Count > 0)
                writer.WriteArray("removeitems", request.ItemsToRemove);

            writer.WriteEndObject();
            writer.WriteEndObject();
        }
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			var f = value as IGeoBoundingBoxFilter;
			if (f == null || (f.IsConditionless && !f.IsVerbatim)) return;
			
			var contract = serializer.ContractResolver as SettingsContractResolver;
			if (contract == null)
				return;
			
			var field = contract.Infer.PropertyPath(f.Field);
			if (field.IsNullOrEmpty())
				return;

			writer.WriteStartObject();
			{
				writer.WritePropertyName(field);
				writer.WriteStartObject();
				{
					WriteProperty(writer, f, "top_left", f.TopLeft);
					WriteProperty(writer, f, "bottom_right", f.BottomRight);
				}
				writer.WriteEndObject();
				SerializeProperty(writer, serializer, f, "type", f.GeoExecution);
				
				WriteProperty(writer, f, "_cache", f.Cache);
				WriteProperty(writer, f, "_cache_key", f.CacheKey);
				WriteProperty(writer, f, "_name", f.FilterName);
			}
			writer.WriteEndObject();
		}
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			TopChildrenQuery term = (TopChildrenQuery)value;
			if (term != null)
			{
				writer.WriteStartObject();
				writer.WritePropertyName("top_children");
				writer.WriteStartObject();

				writer.WritePropertyName("type");
				writer.WriteValue(term.Type);

				writer.WritePropertyName("score");
				writer.WriteValue( term.Score);

				writer.WritePropertyName("factor");
				writer.WriteValue(term.Factor);

				writer.WritePropertyName("incremental_factor");
				writer.WriteValue(term.IncrementalFactor);

				writer.WritePropertyName("query");
				serializer.Serialize(writer, term.Query);

				writer.WriteEndObject();
				writer.WriteEndObject();
			}
		}
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			ElasticQuery term = (ElasticQuery)value;
			if (term != null)
			{
				writer.WriteStartObject();

				writer.WriteRaw("\"from\": " + term.From);
				writer.WriteRaw(",\"size\": " + term.Size + ",");
				writer.WritePropertyName("query");
				serializer.Serialize(writer, term.Query);

				if (term.Fields != null && term.Fields.Count > 0)
				{
					writer.WritePropertyName("fields");
					writer.WriteStartArray();
					foreach (var field in term.Fields)
					{
						writer.WriteRawValue("\"" + field + "\"");
					}
					writer.WriteEndArray();
				}
				if (term.SortItems != null && term.SortItems.Count > 0)
				{
					writer.WritePropertyName("sort");
					writer.WriteStartObject();
					foreach (var sortItem in term.SortItems)
					{
					    if (sortItem != null)
					    {
					        writer.WritePropertyName(sortItem.FieldName);
					        writer.WriteValue(sortItem.SortType.ToString().ToLower());
					    }
					}

					writer.WriteEndObject();
				}

                //facets
                if (term.Facets != null)
                {
                    writer.WritePropertyName("facets");
                    serializer.Serialize(writer, term.Facets);
                }

                //hightlight
                if(term.Hightlight!=null)
                {
                    writer.WritePropertyName("highlight");
                    serializer.Serialize(writer,term.Hightlight);
                }

                if (term.Explain)
                {
                    writer.WriteRaw(",\"explain\": " + term.Explain.ToString().ToLower());
                }

				writer.WriteEndObject();
			}
		}
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            PacketEffect effect = (PacketEffect)value;
                PacketEffectAttribute effectAttribute = effect.GetType().GetCustomAttribute<PacketEffectAttribute>();
                if (effectAttribute == null)
                    throw new NotSupportedException("All PacketEffect classes must have a PacketEffectAttribute !");

                writer.WriteStartObject();
                writer.WritePropertyName(effectAttribute.Name);
                writer.WriteStartObject();
                foreach (PropertyInfo info in value.GetType().GetProperties())
                {
                    string propertyName;
                    JsonPropertyAttribute propertyAttribute = info.GetCustomAttribute<JsonPropertyAttribute>();
                    if (propertyAttribute != null)
                        propertyName = propertyAttribute.PropertyName;
                    else
                        propertyName = info.Name;
                    writer.WritePropertyName(propertyName);

                    JsonConverterAttribute conversionAttribute = info.GetCustomAttribute<JsonConverterAttribute>();
                    if (conversionAttribute != null)
                        writer.WriteRawValue(JsonConvert.SerializeObject(info.GetValue(value), Formatting.None, (JsonConverter)Activator.CreateInstance(conversionAttribute.ConverterType)));
                    else
                        writer.WriteRawValue(JsonConvert.SerializeObject(info.GetValue(value)));
                }
                writer.WriteEndObject();
                writer.WriteEndObject();
        }
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			CustomFiltersScoreQuery term = (CustomFiltersScoreQuery)value;
			if (term != null)
			{
				writer.WriteStartObject();
				writer.WritePropertyName("custom_filters_score");
				writer.WriteStartObject();
				writer.WritePropertyName("query");
				serializer.Serialize(writer,term.Query);
				writer.WritePropertyName("filters");

				writer.WriteStartArray();
				foreach (var filter in term.Filters)
				{
					serializer.Serialize(writer,filter);
				}
				writer.WriteEndArray();

				writer.WritePropertyName("score_mode");
				writer.WriteValue(term.ScoreMode);

				writer.WritePropertyName("script");
				writer.WriteValue(term.Script);

				writer.WriteEndObject();
				writer.WriteEndObject();
			}
		}
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     TermsFacet term = (TermsFacet)value;
     if (term != null)
     {
         if (term.facetItems != null)
         {
             writer.WriteStartObject();
             foreach (TermsFacet.TermsFacetItem termsFacetItem in term.facetItems)
             {
                 writer.WritePropertyName(termsFacetItem.FacetName);
                 writer.WriteStartObject();
                 //1
                 writer.WritePropertyName("terms");
                 writer.WriteStartObject();
                 writer.WritePropertyName("field");
                 writer.WriteValue(termsFacetItem.Field);
                 writer.WritePropertyName("size");
                 writer.WriteValue(termsFacetItem.Size);
                 writer.WriteEndObject();
                 //1
                 writer.WriteEndObject();
             }
             writer.WriteEndObject();
         }
     }
 }
Beispiel #9
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var links = (IList<Link>) value;
            writer.WriteStartObject();

            foreach (var link in links)
            {
                writer.WritePropertyName(link.Rel);
                writer.WriteStartObject();
                writer.WritePropertyName("href");
                writer.WriteValue(link.Href);

                if (link.IsTemplated)
                {
                    writer.WritePropertyName("isTemplated");
                    writer.WriteValue(true);
                }

                if (!string.IsNullOrWhiteSpace(link.Title))
                {
                    writer.WritePropertyName("title");
                    writer.WriteValue(link.Title);
                }
                

                writer.WriteEndObject();
            }
            writer.WriteEndObject();
        }
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     var facetRequest = (NestedDateHistogramFacetRequest)value;
     writer.WriteStartObject();
     writer.WritePropertyName("date_histogram");
     writer.WriteStartObject();
     if (facetRequest.Field.IsNotNullOrEmpty())
     {
         writer.WritePropertyName("field");
         writer.WriteValue(facetRequest.Field);
     }
     if (facetRequest.Interval.IsNotNull())
     {
         writer.WritePropertyName("interval");
         writer.WriteValue(facetRequest.Interval.ToString().ToLowerInvariant());
     }
     if (facetRequest.PreTimeZone.IsNotNull())
     {
         writer.WritePropertyName("pre_zone");
         writer.WriteValue(facetRequest.PreTimeZone.BaseUtcOffset.ToString(@"hh\:mm"));
     }
     writer.WriteEndObject();
     if (facetRequest.Nested.IsNotNullOrEmpty())
     {
         writer.WritePropertyName("nested");
         writer.WriteValue(facetRequest.Nested);
     }
     if (facetRequest.FacetFilter.IsNotNull())
     {
         writer.WritePropertyName("facet_filter");
         serializer.Serialize(writer, facetRequest.FacetFilter);
     }
     writer.WriteEndObject();
 }
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			TermQuery term = (TermQuery)value;
            if (term != null)
            {
                /* Writes the following json
                 *  {
                 *      "term":
                 *      {
                 *          "term.Field": 
                 *          {
                 *              "term": "term.Value",
                 *              "boost": term.Boost
                 *          }
                 *      }
                 *  }
                 */

                writer.WriteStartObject();
                writer.WritePropertyName("term");
                writer.WriteStartObject();
                writer.WritePropertyName(term.Field);
                writer.WriteStartObject();
                writer.WritePropertyName("term");
                writer.WriteValue(term.Value);
                writer.WritePropertyName("boost");
                writer.WriteValue(term.Boost);
                writer.WriteEndObject();
                writer.WriteEndObject();
                writer.WriteEndObject();
            }
            //writer.WriteRawValue(string.Format("{{term: {{ \"{0}\" : {{ \"term\" : \"{1}\", \"boost\":{2} }}}} }}", term.Field, term.Value, term.Boost));
		}
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var list = (HalResource)value;

            list.Links.Add(new Link
            {
                Rel = "self",
                Href = list.Href
            });

            writer.WriteStartObject();
            writer.WritePropertyName("_links");
            serializer.Serialize(writer, list.Links);

            writer.WritePropertyName("_embedded");
            writer.WriteStartObject();
            writer.WritePropertyName(list.Rel);
            writer.WriteStartArray();
            foreach (HalResource halResource in (IEnumerable)value)
            {
                serializer.Serialize(writer, halResource);
            }
            writer.WriteEndArray();
            writer.WriteEndObject();
            writer.WriteEndObject();
        }
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			DisjunctionMaxQuery term = (DisjunctionMaxQuery)value;
			if (term != null)
			{
				if (term.Queries == null || term.Queries.Count < 0)
				{
					throw new ArgumentException();
				}

				writer.WriteStartObject();
				writer.WritePropertyName("dis_max");
				writer.WriteStartObject();
				writer.WritePropertyName("tie_breaker");
				writer.WriteValue(term.TieBreaker);
				writer.WritePropertyName("boost");
				writer.WriteValue(term.Boost);
				writer.WritePropertyName("queries");
				writer.WriteStartArray();
				foreach (var query in term.Queries)
				{
					serializer.Serialize(writer, query);
				}
				writer.WriteEndArray();
				writer.WriteEndObject();
				writer.WriteEndObject();
			}
		}
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     IFieldQuery fq = value as IFieldQuery;
     if (fq != null)
     {
         writer.WriteStartObject();
         writer.WritePropertyName(fq.Field);
         writer.WriteStartObject();
         if (fq is IValue)
         {
             IValue v = fq as IValue;
             writer.WritePropertyName("value");
             writer.WriteValue(v.Value);
         }
         if (fq.Boost != 1.0)
         {
             writer.WritePropertyName("boost");
             writer.WriteValue(fq.Boost);
         }
         writer.WriteEndObject();
         writer.WriteEndObject();
     }
     else
         writer.WriteNull();
 }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (writer == null)
                throw new ArgumentNullException("writer");
            if (value == null)
                throw new ArgumentNullException("value");
            if (serializer == null)
                throw new ArgumentNullException("serializer");
            if (!(value is IFeature))
            {
                string s = String.Format("IFeature expected but was {0}", value.GetType().Name);
                throw new ArgumentException(s);
            }

            writer.WriteStartObject();
            writer.WritePropertyName("type");
            writer.WriteValue("Topology");

            writer.WritePropertyName("objects");
            writer.WriteStartObject();
            writer.WritePropertyName("data");
            IEnumerable<Coordinate[]> arcs = WriteFeature(writer, serializer, (IFeature)value);
            writer.WriteEndObject();

            WriteArcs(writer, serializer, arcs);
            writer.WriteEndObject();
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            GeoDistanceFilter term = (GeoDistanceFilter)value;
            if (term != null)
            {

                writer.WriteStartObject();
                writer.WritePropertyName("geo_distance");
                writer.WriteStartObject();

                if (!string.IsNullOrEmpty(term.Distance))
                {
                    writer.WritePropertyName("distance");
                    writer.WriteValue(term.Distance);

                    if (!string.IsNullOrEmpty(term.DistanceType))
                    {
                        writer.WritePropertyName("distance_type");
                        writer.WriteValue(term.DistanceType);
                    }
                    if (!string.IsNullOrEmpty(term.Field))
                    {
                        writer.WritePropertyName(term.Field);
                        writer.WriteValue(term.Location);
                    }

                }
                writer.WriteEndObject();
                writer.WriteEndObject();
            }
        }
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     if (value.IsNot<NestedFilter>())
     {
         writer.WriteNull();
         return;
     }
     var filter = (NestedFilter)value;
     writer.WriteStartObject();
     writer.WritePropertyName("nested");
     writer.WriteStartObject();
     if (filter.Path.IsNotNull())
     {
         writer.WritePropertyName("path");
         writer.WriteValue(filter.Path);
     }
     writer.WritePropertyName("filter");
     serializer.Serialize(writer, filter.Filter);
     if (filter.Join.IsNotNull())
     {
         writer.WritePropertyName("join");
         writer.WriteValue(filter.Join);
     }
     writer.WriteEndObject();
     writer.WriteEndObject();
 }
        public override void WriteJson(JsonWriter __writer, object __value, JsonSerializer __serializer)
        {
            var __对象 = (M接收事件)__value;
            __writer.WriteStartObject();
            __writer.WritePropertyName("对象名称");
            __writer.WriteValue(__对象.对象名称);
            __writer.WritePropertyName("事件名称");
            __writer.WriteValue(__对象.事件名称);
            __writer.WritePropertyName("实参列表");
            __writer.WriteStartArray();
            if (__对象.实参列表 != null)
            {
                foreach (var __kv in __对象.实参列表)
                {
                    __writer.WriteStartObject();
                    __writer.WritePropertyName("名称");
                    __writer.WriteValue(__kv.名称);
                    __writer.WritePropertyName("值");

                    if (__kv.值.TrimStart().StartsWith("{") || __kv.值.TrimStart().StartsWith("["))
                    {
                        __writer.WriteRawValue(__kv.值);
                    }
                    else
                    {
                        __writer.WriteValue(__kv.值);
                    }
                    __writer.WriteEndObject();
                }
            }
            __writer.WriteEndArray();
            __writer.WriteEndObject();
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var links = new HashSet<Link>((IList<Link>)value, new LinkEqualityComparer());

            writer.WriteStartObject();

            var lookup = links.ToLookup(l => l.Rel);

            foreach (var rel in lookup)
            {
                writer.WritePropertyName(rel.Key);
                if (rel.Count() > 1)
                    writer.WriteStartArray();
                foreach (var link in rel)
                {
                    writer.WriteStartObject();
                    writer.WritePropertyName("href");
                    writer.WriteValue(ResolveUri(link.Href));

                    if (link.IsTemplated)
                    {
                        writer.WritePropertyName("templated");
                        writer.WriteValue(true);
                    }

                    writer.WriteEndObject();
                }
                if (rel.Count() > 1)
                    writer.WriteEndArray();
            }
            writer.WriteEndObject();
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            NestedFilter term = (NestedFilter)value;
            if (term != null)
            {

                writer.WriteStartObject();
                writer.WritePropertyName("nested");
                writer.WriteStartObject();

                writer.WritePropertyName("path");
                writer.WriteValue(term.Path);
                writer.WritePropertyName("query");
                if(term.Query!=null)
                {
                    serializer.Serialize(writer, term.Query);
                }
                else
                {
                    serializer.Serialize(writer, term.Filter);
                }
//                writer.WritePropertyName("_cache");
//                writer.WriteValue(term.Cache);
                writer.WriteEndObject();
                writer.WriteEndObject();
            }
        }
Beispiel #21
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var term = value as Term;
            if (term != null)
            {
                writer.WriteStartObject();
                writer.WritePropertyName(term.Field);
                writer.WriteStartObject();

                    writer.WritePropertyName("value");
                    writer.WriteValue(term.Value);

                if (term.Boost.HasValue)
                {
                    writer.WritePropertyName("boost");
                    writer.WriteValue(term.Boost.Value);
                }
                var multiTerm = value as IMultiTermQuery;
                if (multiTerm != null)
                {
                    if (multiTerm.Rewrite.HasValue)
                    {
                        writer.WritePropertyName("rewrite");
                        writer.WriteValue(Enum.GetName(typeof(RewriteMultiTerm), multiTerm.Rewrite.Value));
                    }
                }

                writer.WriteEndObject();
                writer.WriteEndObject();
            }
            else
                writer.WriteNull();
        }
Beispiel #22
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var poi = (PoiData)value;

            writer.WriteStartObject();

            if (!string.IsNullOrEmpty(poi.Id))
            {
                writer.WritePropertyName(poi.Id);
                writer.WriteStartObject();
            }

            WriteNewObject(writer, poi, serializer, "fw_core", poi.Core);
            WriteNewObject(writer, poi, serializer, "fw_time", poi.Time);
            WriteNewObject(writer, poi, serializer, "fw_xml3d", poi.Xml3ds);
            WriteNewObject(writer, poi, serializer, "fw_contact", poi.Contacts);
            WriteNewObject(writer, poi, serializer, "fw_media", poi.Media);
            WriteNewObject(writer, poi, serializer, "fw_relationships", poi.Relationships);
            WriteNewObject(writer, poi, serializer, "fw_marker", poi.Markers);

            if (!string.IsNullOrEmpty(poi.Id))
            {
                writer.WriteEndObject();
            }

            writer.WriteEndObject();
        }
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			CustomScoreQuery term = (CustomScoreQuery)value;
			if (term != null)
			{
				writer.WriteStartObject();

				writer.WritePropertyName("custom_score");
				writer.WriteStartObject();
				
				writer.WritePropertyName("query");
				serializer.Serialize(writer, term.Query);

				writer.WritePropertyName("script");
				writer.WriteValue(term.Script);
				if (term.Params != null && term.Params.Count > 0)
				{
					writer.WritePropertyName("params");
					writer.WriteStartObject();
					foreach (var filter in term.Params)
					{
						writer.WritePropertyName(filter.Key);
						writer.WriteValue(filter.Value);
					}
					writer.WriteEndObject();
				}
				writer.WriteEndObject();
				writer.WriteEndObject();
			}
		}
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			FieldQuery term = (FieldQuery)value;
			if (term != null)
			{
				writer.WriteStartObject();
				writer.WritePropertyName("field");
				writer.WriteStartObject();
				writer.WritePropertyName(term.Field);
				writer.WriteValue(term.QueryString);
				
				if(!term.Boost.Equals(default(float)))
				{
					writer.WritePropertyName("boost");
					writer.WriteValue(term.Boost);	
				}

				if (term.EnablePositionIncrements != default(bool))
				{
					writer.WritePropertyName("enable_position_increments");
					writer.WriteValue(term.EnablePositionIncrements.ToString().ToLower());
				}

				writer.WriteEndObject();
				writer.WriteEndObject();
			}
		}
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			var f = value as IFiltersAggregator;
			if (f == null || f.Filters == null) return;

			writer.WriteStartObject();
			writer.WritePropertyName("filters");

			if (!f.Filters.Any(filter => String.IsNullOrEmpty(filter.FilterName)))
			{
				writer.WriteStartObject();
				foreach (var filter in f.Filters)
				{
					writer.WritePropertyName(filter.FilterName);
					serializer.Serialize(writer, filter);
				}
				writer.WriteEndObject();
			}
			else
			{
				serializer.Serialize(writer, f.Filters);
			}

			writer.WriteEndObject();
		}
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			MatchAllQuery term = (MatchAllQuery)value;
			if (term != null)
			{
				writer.WriteStartObject();
				writer.WritePropertyName("match_all");
				writer.WriteStartObject();

				if (!string.IsNullOrEmpty(term.NormsField))
				{
					writer.WritePropertyName("norms_field");
					writer.WriteValue(term.NormsField);
				}

				if (term.Boost > 0)
				{
					writer.WritePropertyName("boost");
					writer.WriteValue(term.Boost);
				}

				writer.WriteEndObject();
				writer.WriteEndObject();
			}
		}
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     // value should be an entity or a collection of entities.
     var singleEntity = !(value is IEnumerable);
     writer.WriteStartObject();
     writer.WritePropertyName("@odata.context");
     writer.WriteValue(GenerateContextUrlString(value, singleEntity));
     if (!singleEntity)
     {
         writer.WritePropertyName("value");
         writer.WriteStartArray();
     }
     if (singleEntity)
     {
         WriteEntity(writer, value);
     }
     else
     {
         foreach (var o in (IEnumerable)value)
         {
             writer.WriteStartObject();
             WriteEntity(writer, o);
             writer.WriteEndObject();
         }
     }
     if (!singleEntity)
     {
         writer.WriteEndArray();
     }
     writer.WriteEndObject();
 }
		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			BoolQuery term = (BoolQuery)value;
			if (term != null)
			{
				writer.WriteStartObject();
				writer.WritePropertyName("bool");
				writer.WriteStartObject();
				bool pre = false;
				if(term.MustQueries!=null&&term.MustQueries.Count>0)
				{
					writer.WritePropertyName("must");
					writer.WriteStartArray();
					foreach (var VARIABLE in term.MustQueries)
					{
						serializer.Serialize(writer, VARIABLE);
					}
					writer.WriteEndArray();
				}
				if (term.MustNotQueries != null&&term.MustNotQueries.Count>0)
				{
					writer.WritePropertyName("must_not");
					writer.WriteStartArray();
					foreach (var VARIABLE in term.MustNotQueries)
					{
						serializer.Serialize(writer, VARIABLE);
					}
					writer.WriteEndArray();
				}
				if (term.ShouldQueries !=null&& term.ShouldQueries.Count > 0)
				{
					writer.WritePropertyName("should");
					writer.WriteStartArray();
					foreach (var shouldQuery in term.ShouldQueries)
					{
						serializer.Serialize(writer,shouldQuery);
					}
					writer.WriteEndArray();
				}
				if (Math.Abs(term.Boost - 1.0) > 0)
				{
					writer.WritePropertyName("boost");
					writer.WriteValue(term.Boost);
				}
				if (term.DisableCoord)
				{
					writer.WritePropertyName("disable_coord");
					writer.WriteValue(term.DisableCoord);
				}
				if (term.MinimumNumberShouldMatch != 1)
				{
					writer.WritePropertyName("minimum_number_should_match");
					writer.WriteValue(term.MinimumNumberShouldMatch);
				}
				writer.WriteEndObject();
				writer.WriteEndObject();
			}
		}
        public void WriteToJson(Newtonsoft.Json.JsonWriter writer)
        {
            writer.WriteStartObject();

            writer.WritePropertyName("title_1");
            writer.WriteValue(Title.Length > 0 ? Title[0] : "");

            writer.WritePropertyName("title_2");
            writer.WriteValue(Title.Length > 1 ? Title[1] : "");

            writer.WritePropertyName("colour");
            if (Color == null)
            {
                new RgbColor(255, 255, 255).WriteToJson(writer);
            }
            else
            {
                Color.WriteToJson(writer);
            }

            writer.WritePropertyName("weight");
            writer.WriteValue(Weight);

            // Write descriptions
            for (int i = 0; i < Description.Length; i++)
            {
                writer.WritePropertyName("description_" + (i + 1));
                writer.WriteValue(Description[i]);
            }
            for (int i = Description.Length; i < 10; i++)
            {
                writer.WritePropertyName("description_" + (i + 1));
                writer.WriteValue("");
            }

            writer.WritePropertyName("preview_scale");
            writer.WriteValue(PreviewScale);

            // Write preview offset if not default
            if (PreviewOffset != NoOffset && (PreviewOffset != null && PreviewOffset.Length == 3))
            {
                writer.WritePropertyName("preview_offset");
                writer.WriteStartObject();
                writer.WritePropertyName("x");
                writer.WriteValue(PreviewOffset[0]);
                writer.WritePropertyName("y");
                writer.WriteValue(PreviewOffset[1]);
                writer.WritePropertyName("z");
                writer.WriteValue(PreviewOffset[2]);
                writer.WriteEndObject();
            }

            writer.WriteEndObject();
        }
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     writer.WriteStartObject();
     foreach (var command in (ProfileCommandDataCollection)value)
     {
         writer.WritePropertyName(command.Name);
         writer.WriteStartObject();
         writer.WritePropertyName("Href");
         writer.WriteValue(command.Uri);
         writer.WriteEndObject();
     }
     writer.WriteEndObject();
 }
Beispiel #31
0
        void ParseGroup(TextGroupDefinition group)
        {
            _writer.WritePropertyName(group.Name);
            if (!group.RecordBreakOnLine)
            {
                _writer.WriteStartObject();
            }
            else
            {
                _writer.WriteStartArray();
            }
            int lineNo = 0;

            while (!_reader.EndOfStream)
            {
                if (_line == null || lineNo > 0)
                {
                    _line = _reader.ReadLine();
                }
                lineNo++;
                if (_line.Trim() != string.Empty && lineNo >= group.ElementsStartOnLine)
                {
                    if (group.EndString != null && _line.Contains(group.EndString))
                    {
                        break;
                    }
                    if (group.RecordBreakOnLine)
                    {
                        _writer.WriteStartObject();
                    }

                    foreach (var subGroup in group.Groups)
                    {
                        if (_line.Contains(subGroup.StartString))
                        {
                            ParseGroup(subGroup);
                        }
                    }

                    foreach (var element in group.Elements)
                    {
                        ParseElement(element, lineNo);
                    }
                    if (group.RecordBreakOnLine)
                    {
                        _writer.WriteEnd();
                    }
                }
            }
            _writer.WriteEnd();              // object or array
        }
Beispiel #32
0
        public override void WriteJson(Newton.JsonWriter writer, object value, Newton.JsonSerializer serializer)
        {
            var lazyMgr = value as ILazyManager;

            writer.WriteStartObject();

            var contract = (Newton.Serialization.JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType());

            foreach (var property in contract.Properties)
            {
                if (lazyMgr.IsValueCreated(property.PropertyName))
                {
                    var pValue = property.ValueProvider.GetValue(value);
                    if (pValue == null && serializer.NullValueHandling == Newton.NullValueHandling.Ignore)
                    {
                        continue;
                    }

                    writer.WritePropertyName(property.PropertyName);
                    serializer.Serialize(writer, pValue);
                }
            }

            writer.WriteEndObject();
        }
Beispiel #33
0
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     writer.WriteStartObject();
     writer.WritePropertyName("notWrittenByDefaultSerializer");
     writer.WriteValue("written");
     writer.WriteEndObject();
 }
 public void WriteToJson(Newtonsoft.Json.JsonWriter writer)
 {
     writer.WriteStartObject();
     writer.WritePropertyName("name");
     writer.WriteValue(this.Name);
     writer.WritePropertyName("prop");
     writer.WriteValue(this.Prop);
     writer.WritePropertyName("rotation");
     writer.WriteStartArray();
     foreach (Rotation r in this.Rotations)
     {
         r.WriteToJson(writer);
     }
     writer.WriteEndArray();
     writer.WriteEndObject();
 }
        public override void WriteJson(Newton.JsonWriter writer, object value, Newton.JsonSerializer serializer)
        {
            var result = value as IResult;

            writer.WriteStartObject();

            writer.WritePropertyName("succeed");
            serializer.Serialize(writer, result.Succeed);

            writer.WritePropertyName("data");
            serializer.Serialize(writer, result.Data);

            if (!string.IsNullOrEmpty(result.Message))
            {
                writer.WritePropertyName("msg");
                serializer.Serialize(writer, result.Message);
            }

            writer.WriteEndObject();
        }
 private void WriteConnectedObjects(ChildTableQuery ctq, SQLiteDataReader sdr, Newtonsoft.Json.JsonWriter wr, bool includeThids)
 {
     //string value;
     wr.WritePropertyName(ctq.Connection.FullName);
     wr.WriteStartArray();
     while (sdr.Read())
     {
         wr.WriteStartObject();
         if (_settings.IncludeConnectionInfo)
         {
             wr.WritePropertyName("Connection");
             wr.WriteValue(ctq.Connection.Name);
             wr.WritePropertyName("ToCategory");
             wr.WriteValue(ctq.Connection.ToCategory);
         }
         WriteObjects(sdr, wr, includeThids);
         wr.WriteEndObject();
     }
     wr.WriteEndArray();
 }
Beispiel #37
0
        public override void WriteJson(JsonWriter writer, JsonApiRelationshipObjectBase value, JsonSerializer serializer)
        {
            if (value == null)
            {
                return;
            }
            // write "{"
            writer.WriteStartObject();
            // write "data:"
            writer.WritePropertyName("data");

            switch (value)
            {
            case JsonApiToOneRelationshipObject valueToOne:
                WriteToOneRelationship(writer, valueToOne, serializer);
                break;

            case JsonApiToManyRelationshipObject valueToMany:
                WriteToManyRelationship(writer, valueToMany, serializer);
                break;

            default:
                throw new ArgumentException($"{nameof(JsonApiRelationshipObjectConverter)}.{nameof(WriteJson)}: {nameof(value)} does not have a supported type. Found type: {value.GetType().Name}", nameof(value));
            }

            if (value.Links != null)
            {
                // write "links:"
                writer.WritePropertyName("links");
                serializer.Serialize(writer, value.Links);
            }
            if (value.Meta != null)
            {
                // write "meta:"
                writer.WritePropertyName("meta");
                serializer.Serialize(writer, value.Meta);
            }
            // write "}"
            writer.WriteEndObject();
        }
Beispiel #38
0
        /// <summary>
        /// Writes the json.
        /// </summary>
        /// <param name="writer">The writer.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The serializer.</param>
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
        {
            DataTable table = value as DataTable;

            writer.WriteStartObject();

            writer.WritePropertyName("TableName");
            writer.WriteValue(table.TableName);

            writer.WritePropertyName("Columns");
            writer.WriteStartArray();

            foreach (DataColumn column in table.Columns)
            {
                writer.WriteStartObject();

                writer.WritePropertyName("AllowDBNull");
                writer.WriteValue(column.AllowDBNull);
                writer.WritePropertyName("AutoIncrement");
                writer.WriteValue(column.AutoIncrement);
                writer.WritePropertyName("AutoIncrementSeed");
                writer.WriteValue(column.AutoIncrementSeed);
                writer.WritePropertyName("AutoIncrementStep");
                writer.WriteValue(column.AutoIncrementStep);
                writer.WritePropertyName("Caption");
                writer.WriteValue(column.Caption);
                writer.WritePropertyName("ColumnName");
                writer.WriteValue(column.ColumnName);
                writer.WritePropertyName("DataType");
                writer.WriteValue(column.DataType.Name);
                writer.WritePropertyName("DateTimeMode");
                writer.WriteValue(column.DateTimeMode.ToString());
                writer.WritePropertyName("DefaultValue");
                writer.WriteValue(column.DefaultValue);
                writer.WritePropertyName("MaxLength");
                writer.WriteValue(column.MaxLength);
                writer.WritePropertyName("Ordinal");
                writer.WriteValue(column.Ordinal);
                writer.WritePropertyName("ReadOnly");
                writer.WriteValue(column.ReadOnly);
                writer.WritePropertyName("Unique");
                writer.WriteValue(column.Unique);

                writer.WriteEndObject();
            }

            writer.WriteEndArray();

            writer.WritePropertyName("Rows");
            writer.WriteStartArray();

            foreach (DataRow row in table.Rows)
            {
                if (row.RowState != DataRowState.Deleted && row.RowState != DataRowState.Detached)
                {
                    writer.WriteStartArray();

                    for (int index = 0; index <= table.Columns.Count - 1; index++)
                    {
                        writer.WriteValue(row[index]);
                    }

                    writer.WriteEndArray();
                }
            }

            writer.WriteEndArray();

            // Write out primary key if the table has one. This will be useful when deserializing the table.
            // We will write it out as an array of column names
            writer.WritePropertyName("PrimaryKey");
            writer.WriteStartArray();
            if (table.PrimaryKey.Length > 0)
            {
                foreach (DataColumn column in table.PrimaryKey)
                {
                    writer.WriteValue(column.ColumnName);
                }
            }
            writer.WriteEndArray();

            writer.WriteEndObject();
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var facetRequest = (NestedTermsFacetRequest)value;
            writer.WriteStartObject();
            writer.WritePropertyName("terms");
            writer.WriteStartObject();
            if (facetRequest.Field.IsNotNullOrEmpty())
            {
                writer.WritePropertyName("field");
                writer.WriteValue(facetRequest.Field);
            }
            if (facetRequest.Fields.IsNotNull() && facetRequest.Fields.Any())
            {
                writer.WritePropertyName("fields");
                writer.WriteStartArray();
                foreach (var field in facetRequest.Fields)
                {
                    serializer.Serialize(writer, field);
                }
                writer.WriteEndArray();
            }
            if (facetRequest.Script.IsNotNullOrEmpty())
            {
                writer.WritePropertyName("script");
                writer.WriteValue(facetRequest.Script);
            }
            if (facetRequest.AllTerms)
            {
                writer.WritePropertyName("all_terms");
                writer.WriteValue(true);
            }
            if (facetRequest.Size.HasValue)
            {
                if (facetRequest.Size.Value < MinSize)
                {
                    throw new InvalidSearchRequestException(string.Format(CultureInfo.InvariantCulture, "Terms facet size can not be set to a lower value than 0. Current value: '{0}'", facetRequest.Size.Value));
                }

                if (facetRequest.Size.Value > MaxSize)
                {
                    throw new InvalidSearchRequestException(string.Format(CultureInfo.InvariantCulture, "Terms facet size can not be set to a higher value than 1000. Current value: '{0}'", facetRequest.Size.Value));
                }

                writer.WritePropertyName("size");
                writer.WriteValue(facetRequest.Size.Value);
            }
            writer.WriteEndObject();
            if (facetRequest.Nested.IsNotNullOrEmpty())
            {
                writer.WritePropertyName("nested");
                writer.WriteValue(facetRequest.Nested);
            }
            if (facetRequest.FacetFilter.IsNotNull())
            {
                writer.WritePropertyName("facet_filter");
                serializer.Serialize(writer, facetRequest.FacetFilter);
            }
            writer.WriteEndObject();
        }