Example #1
0
        // Constructor
        public MainPage()
        {
            InitializeComponent();

            this.webHybrid = new WebHybrid(this.webView, new JsonSerializer());

            SaveFilesInHTMLFolderToIsoStore();
            this.webView.Navigate(new Uri("HTML/home.html", UriKind.Relative));

            //var fi = new FileInfo(@"./Assets/home.html");

            //using (var streamReader = new StreamReader(fi.FullName))
            //{
            //    this.webView.NavigateToString(streamReader.ReadToEnd());
            //}

            this.webHybrid.RegisterCallback("test", s =>
                {
                    System.Diagnostics.Debug.WriteLine(s);
                    var serializer = new JsonSerializer();
                    var m = serializer.Deserialize<ChartViewModel>(s);
                    System.Diagnostics.Debug.WriteLine(m);
                });

            this.webHybrid.RegisterCallback("dataCallback", s => System.Diagnostics.Debug.WriteLine(s));
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            string text;

            if (value is DateTime)
            {
                DateTime dateTime = (DateTime)value;

                if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
                    || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
                    dateTime = dateTime.ToUniversalTime();

                text = dateTime.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
            }
#if !NET20
            else if (value is DateTimeOffset)
            {
                DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
                if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal
                    || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal)
                    dateTimeOffset = dateTimeOffset.ToUniversalTime();

                text = dateTimeOffset.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture);
            }
#endif
            else
            {
                throw new JsonSerializationException("Unexpected value when converting date. Expected DateTime or DateTimeOffset, got {0}.".FormatWith(CultureInfo.InvariantCulture, ReflectionUtils.GetObjectType(value)));
            }

            writer.WriteValue(text);
        }
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      long ticks;

      if (value is DateTime)
      {
        DateTime dateTime = (DateTime)value;
        DateTime utcDateTime = dateTime.ToUniversalTime();
        ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTime);
      }
#if !PocketPC && !NET20
      else if (value is DateTimeOffset)
      {
        DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
        DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
        ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
      }
#endif
      else
      {
        throw new JsonSerializationException("Expected date object value.");
      }

      writer.WriteStartConstructor("Date");
      writer.WriteValue(ticks);
      writer.WriteEndConstructor();
    }
        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
        /// <param name="objectType">Type of the object.</param>
        /// <param name="existingValue">The existing value of object being read.</param>
        /// <param name="serializer">The calling serializer.</param>
        /// <returns>The object value.</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            DataTable dt = existingValue as DataTable;

            if (dt == null)
            {
                // handle typed datasets
                dt = (objectType == typeof(DataTable))
                    ? new DataTable()
                    : (DataTable)Activator.CreateInstance(objectType);
            }

            if (reader.TokenType == JsonToken.PropertyName)
            {
                dt.TableName = (string)reader.Value;

                CheckedRead(reader);
            }

            if (reader.TokenType != JsonToken.StartArray)
                throw JsonSerializationException.Create(reader, "Unexpected JSON token when reading DataTable. Expected StartArray, got {0}.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));

            CheckedRead(reader);

            while (reader.TokenType != JsonToken.EndArray)
            {
                CreateRow(reader, dt);

                CheckedRead(reader);
            }

            return dt;
        }
        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
        /// <param name="objectType">Type of the object.</param>
        /// <param name="existingValue">The existing value of object being read.</param>
        /// <param name="serializer">The calling serializer.</param>
        /// <returns>The object value.</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            DataTable dt = existingValue as DataTable;

            if (dt == null)
            {
                // handle typed datasets
                dt = (objectType == typeof(DataTable))
                    ? new DataTable()
                    : (DataTable)Activator.CreateInstance(objectType);
            }

            if (reader.TokenType == JsonToken.PropertyName)
            {
                dt.TableName = (string)reader.Value;

                reader.Read();
            }

            if (reader.TokenType == JsonToken.StartArray)
                reader.Read();

            while (reader.TokenType != JsonToken.EndArray)
            {
                CreateRow(reader, dt);

                reader.Read();
            }

            return dt;
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            EnsureReflectionObject(value.GetType());

            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

            string keyName = (string)_reflectionObject.GetValue(value, KeyPropertyName);
            object keyValue = _reflectionObject.GetValue(value, ValuePropertyName);

            Type keyValueType = (keyValue != null) ? keyValue.GetType() : null;

            writer.WriteStartObject();
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyPropertyName) : KeyPropertyName);
            writer.WriteValue(keyName);
            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(TypePropertyName) : TypePropertyName);
            writer.WriteValue((keyValueType != null) ? keyValueType.FullName : null);

            writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValuePropertyName) : ValuePropertyName);

            if (keyValueType != null)
            {
                string valueJson;
                if (JsonSerializerInternalWriter.TryConvertToString(keyValue, keyValueType, out valueJson))
                    writer.WriteValue(valueJson);
                else
                    writer.WriteValue(keyValue);
            }
            else
            {
                writer.WriteNull();
            }

            writer.WriteEndObject();
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            NameContainer nameContainer = new NameContainer();
            nameContainer.Value = (string)reader.Value;

            return nameContainer;
        }
Example #8
0
    public void EntitiesTest()
    {
      Purchase purchase = new Purchase() { Id = 1 };
      purchase.PurchaseLine.Add(new PurchaseLine() { Id = 1, Purchase = purchase });
      purchase.PurchaseLine.Add(new PurchaseLine() { Id = 2, Purchase = purchase });

      StringWriter sw = new StringWriter();
      JsonSerializer serializer = new JsonSerializer();
      serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

      using (JsonWriter jw = new JsonTextWriter(sw))
      {
        jw.Formatting = Formatting.Indented;

        serializer.Serialize(jw, purchase);
      }

      string json = sw.ToString();

      Assert.AreEqual(@"{
  ""Id"": 1,
  ""PurchaseLine"": [
    {
      ""Id"": 1,
      ""PurchaseReference"": {
        ""EntityKey"": null,
        ""RelationshipName"": ""EntityDataModel.PurchasePurchaseLine"",
        ""SourceRoleName"": ""PurchaseLine"",
        ""TargetRoleName"": ""Purchase"",
        ""RelationshipSet"": null,
        ""IsLoaded"": false
      },
      ""EntityState"": 1,
      ""EntityKey"": null
    },
    {
      ""Id"": 2,
      ""PurchaseReference"": {
        ""EntityKey"": null,
        ""RelationshipName"": ""EntityDataModel.PurchasePurchaseLine"",
        ""SourceRoleName"": ""PurchaseLine"",
        ""TargetRoleName"": ""Purchase"",
        ""RelationshipSet"": null,
        ""IsLoaded"": false
      },
      ""EntityState"": 1,
      ""EntityKey"": null
    }
  ],
  ""EntityState"": 1,
  ""EntityKey"": null
}", json);

      Purchase newPurchase = JsonConvert.DeserializeObject<Purchase>(json);
      Assert.AreEqual(1, newPurchase.Id);

      Assert.AreEqual(2, newPurchase.PurchaseLine.Count);
      Assert.AreEqual(1, newPurchase.PurchaseLine.ElementAt(0).Id);
      Assert.AreEqual(2, newPurchase.PurchaseLine.ElementAt(1).Id);
    }
 /// <summary>
 /// Reads the JSON representation of the object.
 /// </summary>
 /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
 /// <param name="objectType">Type of the object.</param>
 /// <param name="existingValue">The existing property value of the JSON that is being converted.</param>
 /// <param name="serializer">The calling serializer.</param>
 /// <returns>The object value.</returns>
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     if (reader.TokenType == JsonToken.Null)
     {
         return null;
     }
     else
     {
         if (reader.TokenType == JsonToken.String)
         {
             try
             {
                 Version v = new Version((string)reader.Value);
                 return v;
             }
             catch (Exception ex)
             {
                 throw JsonSerializationException.Create(reader, "Error parsing version string: {0}".FormatWith(CultureInfo.InvariantCulture, reader.Value), ex);
             }
         }
         else
         {
             throw JsonSerializationException.Create(reader, "Unexpected token or value when parsing version. Token: {0}, Value: {1}".FormatWith(CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
         }
     }
 }
Example #10
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            reader.Read();

            Debug.Assert(reader.TokenType == JsonToken.PropertyName);
            Debug.Assert((string)reader.Value == "coordinates");

            if (objectType == typeof(Coordinate))
            {
                return ReadJsonCoordinate(reader);
            }

            if (typeof(IEnumerable<Coordinate>).IsAssignableFrom(objectType))
            {
                return ReadJsonCoordinates(reader);
            }

            if (typeof(List<Coordinate[]>).IsAssignableFrom(objectType))
            {
                return ReadJsonCoordinatesEnumerable(reader);
            }
            if (typeof(List<List<Coordinate[]>>).IsAssignableFrom(objectType))
            {
                return ReadJsonCoordinatesEnumerable2(reader);
            }

            throw new Exception();
        }
Example #11
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            writer.WritePropertyName("coordinates");

            List<List<Coordinate[]>> coordinatesss = value as List<List<Coordinate[]>>;
            if (coordinatesss != null)
            {
                WriteJsonCoordinatesEnumerable2(writer, coordinatesss, serializer);
                return;
            }

            List<Coordinate[]> coordinatess = value as List<Coordinate[]>;
            if (coordinatess != null)
            {
                WriteJsonCoordinatesEnumerable(writer, coordinatess, serializer);
                return;
            }

            IEnumerable<Coordinate> coordinates = value as IEnumerable<Coordinate>;
            if (coordinates != null)
            {
                WriteJsonCoordinates(writer, coordinates, serializer);
                return;
            }

            Coordinate coordinate = value as Coordinate;
            if (coordinate != null)
            {
                WriteJsonCoordinate(writer, coordinate, serializer);
                return;
            }
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            DataTable table = (DataTable)value;
            DefaultContractResolver resolver = serializer.ContractResolver as DefaultContractResolver;

            writer.WriteStartArray();

            foreach (DataRow row in table.Rows)
            {
                writer.WriteStartObject();
                foreach (DataColumn column in row.Table.Columns)
                {
                    object columnValue = row[column];

                    if (serializer.NullValueHandling == NullValueHandling.Ignore && (columnValue == null || columnValue == DBNull.Value))
                    {
                        continue;
                    }

                    writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(column.ColumnName) : column.ColumnName);
                    serializer.Serialize(writer, columnValue);
                }
                writer.WriteEndObject();
            }

            writer.WriteEndArray();
        }
Example #13
0
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      if (value == null)
      {
        writer.WriteNull();
        return;
      }

      Enum e = (Enum)value;

      string enumName = e.ToString("G");

      if (char.IsNumber(enumName[0]) || enumName[0] == '-')
      {
        writer.WriteValue(value);
      }
      else
      {
        BidirectionalDictionary<string, string> map = GetEnumNameMap(e.GetType());

        string resolvedEnumName;
        map.TryGetByFirst(enumName, out resolvedEnumName);
        resolvedEnumName = resolvedEnumName ?? enumName;

        if (CamelCaseText)
        {
          string[] names = resolvedEnumName.Split(',').Select(item => StringUtils.ToCamelCase(item.Trim())).ToArray();
          resolvedEnumName = string.Join(", ", names);
        }

        writer.WriteValue(resolvedEnumName);
      }
    }
 // Token: 0x06000685 RID: 1669
 // RVA: 0x0003758C File Offset: 0x0003578C
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     if (reader.TokenType == JsonToken.Null)
     {
         if (!ReflectionUtils.IsNullable(objectType))
         {
             throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Cannot convert null value to {0}.", CultureInfo.InvariantCulture, objectType));
         }
         return null;
     }
     else
     {
         if (reader.TokenType != JsonToken.StartConstructor || !string.Equals(reader.Value.ToString(), "Date", StringComparison.Ordinal))
         {
             throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token or value when parsing date. Token: {0}, Value: {1}", CultureInfo.InvariantCulture, reader.TokenType, reader.Value));
         }
         reader.Read();
         if (reader.TokenType != JsonToken.Integer)
         {
             throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token parsing date. Expected Integer, got {0}.", CultureInfo.InvariantCulture, reader.TokenType));
         }
         long javaScriptTicks = (long)reader.Value;
         DateTime dateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(javaScriptTicks);
         reader.Read();
         if (reader.TokenType != JsonToken.EndConstructor)
         {
             throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unexpected token parsing date. Expected EndConstructor, got {0}.", CultureInfo.InvariantCulture, reader.TokenType));
         }
         return dateTime;
     }
 }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">The calling serializer.</param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value == null)
            {
                writer.WriteNull();
                return;
            }

            Enum e = (Enum)value;

            string enumName = e.ToString("G");

            if (char.IsNumber(enumName[0]) || enumName[0] == '-')
            {
                // enum value has no name so write number
                writer.WriteValue(value);
            }
            else
            {
                Type enumType = e.GetType();

                string finalName = EnumUtils.ToEnumName(enumType, enumName, CamelCaseText);

                writer.WriteValue(finalName);
            }
        }
 private static void WriteJsonCoordinatesEnumerable2(JsonWriter writer, List<List<Coordinate[]>> coordinates, JsonSerializer serializer)
 {
     writer.WriteStartArray();
     foreach (List<Coordinate[]> coordinate in coordinates)
         WriteJsonCoordinatesEnumerable(writer, coordinate, serializer);
     writer.WriteEndArray();
 }
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {
      //long ticks;

      /*if (value is DateTime) {
        DateTime dateTime = (DateTime)value;
        DateTime utcDateTime = dateTime.ToUniversalTime();
        ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTime);
      } else if (value is DateTimeOffset) {
        DateTimeOffset dateTimeOffset = (DateTimeOffset)value;
        DateTimeOffset utcDateTimeOffset = dateTimeOffset.ToUniversalTime();
        ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(utcDateTimeOffset.UtcDateTime);
      } else {
        throw new Exception("Expected date object value.");
      }*/

      //writer.WriteStartConstructor("Date");
      //writer.WriteValue(ticks);
      //writer.WriteEndConstructor();
      if (value is DateTime) {
        DateTime dateTime = (DateTime)value;
        DateTime vLocValue = DateTime.SpecifyKind(dateTime, DateTimeKind.Utc);
        writer.WriteValue(vLocValue);
      } else {
        throw new Exception("Expected date object value.");
      }
    }
Example #18
0
        public void Date()
        {
            var serializer = new JsonSerializer();
            DateTime EPOCH = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

            Action<DateTime, string> CheckDate = (date, json) => {
                var result = serializer.Deserialize<DateTime>(json);
                var diff = date.Subtract(result);
                Assert.IsTrue(diff.TotalSeconds < 1, string.Format("Dates do not match: <{0}> != <{1}>, difference: {2}, json: <{3}>", date, result, diff.TotalSeconds, json));
            };

            Action<DateTime> TestDate = (source) => {
                CheckDate(source, string.Format("new Date({0})", (long)(source - EPOCH).TotalMilliseconds));
                CheckDate(source, string.Format("new Date(\"{0}\")", source.ToString("MMMM d, yyyy HH:mm:ss zzz")));
                CheckDate(source, string.Format("new Date({0}, {1}, {2}, {3}, {4}, {5}, {6})", source.Year, source.Month, source.Day, source.Hour, source.Minute, source.Second, source.Millisecond));
            };

            TestDate(new DateTime(1970, 1, 2, 0, 0, 0, DateTimeKind.Utc));
            TestDate(new DateTime(1970, 1, 2, 4, 0, 0, DateTimeKind.Utc));
            TestDate(new DateTime(1970, 1, 2, 14, 0, 0, DateTimeKind.Utc));
            TestDate(DateTime.Now);
            TestDate(DateTime.UtcNow);

            CheckDate(new DateTime(1970, 1, 2, 4, 1, 2), "new Date(1970, 1, 2, 14, 0, 0)");
            CheckDate(new DateTime(1970, 1, 2, 4, 1, 0), "new Date(1970, 1, 2, 14, 0)");
            CheckDate(new DateTime(1970, 1, 2, 4, 0, 0), "new Date(1970, 1, 2, 14)");
            CheckDate(new DateTime(1970, 1, 2, 0, 0, 0), "new Date(1970, 1, 2)");
        }
 private static void WriteJsonCoordinates(JsonWriter writer, IEnumerable<Coordinate> coordinates, JsonSerializer serializer)
 {
     writer.WriteStartArray();
     foreach (Coordinate coordinate in coordinates)
         WriteJsonCoordinate(writer, coordinate, serializer);
     writer.WriteEndArray();
 }
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      IEntityKeyMember entityKeyMember = DynamicWrapper.CreateWrapper<IEntityKeyMember>(value);
      Type keyType = (entityKeyMember.Value != null) ? entityKeyMember.Value.GetType() : null;

      writer.WriteStartObject();
      writer.WritePropertyName("Key");
      writer.WriteValue(entityKeyMember.Key);
      writer.WritePropertyName("Type");
      writer.WriteValue((keyType != null) ? keyType.FullName : null);

      writer.WritePropertyName("Value");

      if (keyType != null)
      {
        string valueJson;
        if (JsonSerializerInternalWriter.TryConvertToString(entityKeyMember.Value, keyType, out valueJson))
          writer.WriteValue(valueJson);
        else
          writer.WriteValue(entityKeyMember.Value);
      }
      else
      {
        writer.WriteNull();
      }

      writer.WriteEndObject();
    }
        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
        /// <param name="objectType">Type of the object.</param>
        /// <param name="existingValue">The existing value of object being read.</param>
        /// <param name="serializer">The calling serializer.</param>
        /// <returns>The object value.</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            // handle typed datasets
            DataSet ds = (objectType == typeof(DataSet))
                ? new DataSet()
                : (DataSet)Activator.CreateInstance(objectType);

            DataTableConverter converter = new DataTableConverter();

            reader.Read();

            while (reader.TokenType == JsonToken.PropertyName)
            {
                DataTable dt = ds.Tables[(string)reader.Value];
                bool exists = (dt != null);

                dt = (DataTable)converter.ReadJson(reader, typeof(DataTable), dt, serializer);

                if (!exists)
                    ds.Tables.Add(dt);

                reader.Read();
            }

            return ds;
        }
Example #22
0
 public MapReduceIndex(Directory directory, int id, IndexDefinition indexDefinition,
                       AbstractViewGenerator viewGenerator, WorkContext context)
     : base(directory, id, indexDefinition, viewGenerator, context)
 {
     jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer();
     jsonSerializer.Converters = MapReduceConverters;
 }
		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			// NOTE: THIS DOESN'T SUPPORT READING OF DynamicJsonObject !!!

			var o = RavenJToken.Load(reader);
			return (o.Type == JTokenType.Null || o.Type == JTokenType.Undefined) ? null : o;
		}
            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                User user = new User();
                user.UserName = (string)reader.Value;

                return user;
            }
        public DatabaseSettingsSectionViewModel()
        {
            serializer = ApplicationModel.Current.Server.Value.DocumentStore.Conventions.CreateSerializer();
            serializer.Formatting = Formatting.Indented;

            SectionName = "Database Settings";
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var converter = GetConverter(value.GetType());
            var text = converter.ConvertToInvariantString(value);

            writer.WriteValue(text);
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if(value == null)
            {
                writer.WriteNull();
                return;
            }

            if ((value as UniquenessType?).HasValue)
                writer.WriteValue(enumToStrings[typeof(UniquenessType?)](value));

            else if ((value as TraversalStrategy?).HasValue)
                writer.WriteValue(enumToStrings[typeof(TraversalStrategy?)](value));

            else if ((value as TraversalOrder?).HasValue)
                writer.WriteValue(enumToStrings[typeof(TraversalOrder?)](value));

            else if ((value as TraversalItemOrder?).HasValue)
                writer.WriteValue(enumToStrings[typeof(TraversalItemOrder?)](value));

            else if ((value as EdgeDirection?).HasValue)
                writer.WriteValue(enumToStrings[typeof(EdgeDirection?)](value));

            else
                throw new InvalidOperationException($"cant find binding to serialize type {value.GetType()}, this is client bug");
        }
        public void testJsonDeserializingAnalyticServiceStatus()
        {
            String source =
                    "{" +
                        "\"service_status\":\"online\"," +
                        "\"api_version\":\"2.0\"," +
                        "\"service_version\":\"1.0.2.63\"," +
                        "\"supported_encoding\":\"UTF-8\"," +
                        "\"supported_compression\":\"gzip\"," +
                        "\"supported_languages\":[" +
                                "\"English\"," +
                                "\"French\"" +
                        "]" +
                    "}";

            ISerializer serializer = new JsonSerializer();
            Status status = serializer.Deserialize<Status>(source);
            Assert.AreEqual("online", status.Service);
            Assert.AreEqual("2.0", status.ApiVersion);
            Assert.AreEqual("1.0.2.63", status.ServiceVersion);
            Assert.AreEqual("UTF-8", status.SupportedEncoding);
            Assert.AreEqual("gzip", status.SupportedCompression);
            Assert.AreEqual(2, status.SupportedLanguages.Count);
            Assert.AreEqual("English", status.SupportedLanguages[0]);
            Assert.AreEqual("French", status.SupportedLanguages[1]);
        }
        public JsonSerializerProxy(JsonSerializerWriter serializerWriter)
        {
            ValidationUtils.ArgumentNotNull(serializerWriter, "serializerWriter");

              _serializerWriter = serializerWriter;
              _serializer = serializerWriter._serializer;
        }
    /// <summary>
    /// Writes the JSON representation of the object.
    /// </summary>
    /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
    /// <param name="value">The value.</param>
    /// <param name="serializer">The calling serializer.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
      if (value == null)
      {
        writer.WriteNull();
        return;
      }

      Enum e = (Enum)value;

      string enumName = e.ToString("G");

      if (char.IsNumber(enumName[0]) || enumName[0] == '-')
      {
        writer.WriteValue(value);
      }
      else
      {
        BidirectionalDictionary<string, string> map = GetEnumNameMap(e.GetType());

        string resolvedEnumName;
        map.TryGetByFirst(enumName, out resolvedEnumName);
        resolvedEnumName = resolvedEnumName ?? enumName;

		if (CamelCaseText)
          resolvedEnumName = StringUtils.ToCamelCase(resolvedEnumName);

        writer.WriteValue(resolvedEnumName);
      }
    }
Example #31
0
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     throw new NotImplementedException();
 }
Example #32
0
 public T As <T>() => JsonSerializer.DeserializeFromString <T>(this.json);
Example #33
0
 public static JsonArrayObjects Parse(string json)
 {
     return(JsonSerializer.DeserializeFromString <JsonArrayObjects>(json));
 }
Example #34
0
        internal static VirtualMachineScaleSetUpdateNetworkConfiguration DeserializeVirtualMachineScaleSetUpdateNetworkConfiguration(JsonElement element)
        {
            Optional <string>             name                  = default;
            Optional <ResourceIdentifier> id                    = default;
            Optional <bool> primary                             = default;
            Optional <bool> enableAcceleratedNetworking         = default;
            Optional <bool> enableFpga                          = default;
            Optional <WritableSubResource> networkSecurityGroup = default;
            Optional <VirtualMachineScaleSetNetworkConfigurationDnsSettings> dnsSettings      = default;
            Optional <IList <VirtualMachineScaleSetUpdateIPConfiguration> >  ipConfigurations = default;
            Optional <bool>          enableIPForwarding = default;
            Optional <DeleteOptions> deleteOption       = default;

            foreach (var property in element.EnumerateObject())
            {
                if (property.NameEquals("name"))
                {
                    name = property.Value.GetString();
                    continue;
                }
                if (property.NameEquals("id"))
                {
                    if (property.Value.ValueKind == JsonValueKind.Null)
                    {
                        property.ThrowNonNullablePropertyIsNull();
                        continue;
                    }
                    id = new ResourceIdentifier(property.Value.GetString());
                    continue;
                }
                if (property.NameEquals("properties"))
                {
                    if (property.Value.ValueKind == JsonValueKind.Null)
                    {
                        property.ThrowNonNullablePropertyIsNull();
                        continue;
                    }
                    foreach (var property0 in property.Value.EnumerateObject())
                    {
                        if (property0.NameEquals("primary"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            primary = property0.Value.GetBoolean();
                            continue;
                        }
                        if (property0.NameEquals("enableAcceleratedNetworking"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            enableAcceleratedNetworking = property0.Value.GetBoolean();
                            continue;
                        }
                        if (property0.NameEquals("enableFpga"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            enableFpga = property0.Value.GetBoolean();
                            continue;
                        }
                        if (property0.NameEquals("networkSecurityGroup"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            networkSecurityGroup = JsonSerializer.Deserialize <WritableSubResource>(property0.Value.ToString());
                            continue;
                        }
                        if (property0.NameEquals("dnsSettings"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            dnsSettings = VirtualMachineScaleSetNetworkConfigurationDnsSettings.DeserializeVirtualMachineScaleSetNetworkConfigurationDnsSettings(property0.Value);
                            continue;
                        }
                        if (property0.NameEquals("ipConfigurations"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            List <VirtualMachineScaleSetUpdateIPConfiguration> array = new List <VirtualMachineScaleSetUpdateIPConfiguration>();
                            foreach (var item in property0.Value.EnumerateArray())
                            {
                                array.Add(VirtualMachineScaleSetUpdateIPConfiguration.DeserializeVirtualMachineScaleSetUpdateIPConfiguration(item));
                            }
                            ipConfigurations = array;
                            continue;
                        }
                        if (property0.NameEquals("enableIPForwarding"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            enableIPForwarding = property0.Value.GetBoolean();
                            continue;
                        }
                        if (property0.NameEquals("deleteOption"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            deleteOption = new DeleteOptions(property0.Value.GetString());
                            continue;
                        }
                    }
                    continue;
                }
            }
            return(new VirtualMachineScaleSetUpdateNetworkConfiguration(id.Value, name.Value, Optional.ToNullable(primary), Optional.ToNullable(enableAcceleratedNetworking), Optional.ToNullable(enableFpga), networkSecurityGroup, dnsSettings.Value, Optional.ToList(ipConfigurations), Optional.ToNullable(enableIPForwarding), Optional.ToNullable(deleteOption)));
        }
Example #35
0
 void IUtf8JsonSerializable.Write(Utf8JsonWriter writer)
 {
     writer.WriteStartObject();
     if (Optional.IsDefined(Name))
     {
         writer.WritePropertyName("name");
         writer.WriteStringValue(Name);
     }
     if (Optional.IsDefined(Id))
     {
         writer.WritePropertyName("id");
         writer.WriteStringValue(Id);
     }
     writer.WritePropertyName("properties");
     writer.WriteStartObject();
     if (Optional.IsDefined(Primary))
     {
         writer.WritePropertyName("primary");
         writer.WriteBooleanValue(Primary.Value);
     }
     if (Optional.IsDefined(EnableAcceleratedNetworking))
     {
         writer.WritePropertyName("enableAcceleratedNetworking");
         writer.WriteBooleanValue(EnableAcceleratedNetworking.Value);
     }
     if (Optional.IsDefined(EnableFpga))
     {
         writer.WritePropertyName("enableFpga");
         writer.WriteBooleanValue(EnableFpga.Value);
     }
     if (Optional.IsDefined(NetworkSecurityGroup))
     {
         writer.WritePropertyName("networkSecurityGroup");
         JsonSerializer.Serialize(writer, NetworkSecurityGroup);
     }
     if (Optional.IsDefined(DnsSettings))
     {
         writer.WritePropertyName("dnsSettings");
         writer.WriteObjectValue(DnsSettings);
     }
     if (Optional.IsCollectionDefined(IPConfigurations))
     {
         writer.WritePropertyName("ipConfigurations");
         writer.WriteStartArray();
         foreach (var item in IPConfigurations)
         {
             writer.WriteObjectValue(item);
         }
         writer.WriteEndArray();
     }
     if (Optional.IsDefined(EnableIPForwarding))
     {
         writer.WritePropertyName("enableIPForwarding");
         writer.WriteBooleanValue(EnableIPForwarding.Value);
     }
     if (Optional.IsDefined(DeleteOption))
     {
         writer.WritePropertyName("deleteOption");
         writer.WriteStringValue(DeleteOption.Value.ToString());
     }
     writer.WriteEndObject();
     writer.WriteEndObject();
 }
Example #36
0
 public override void WriteJson(JsonWriter writer, Version value, JsonSerializer serializer)
 {
     writer.WriteValue(value.ToString());
 }
Example #37
0
        public override Version ReadJson(JsonReader reader, Type objectType, Version existingValue, bool hasExistingValue, JsonSerializer serializer)
        {
            string s = (string)reader.Value;

            return(new Version(s));
        }
        internal static StaticSiteUserProvidedFunctionApp DeserializeStaticSiteUserProvidedFunctionApp(JsonElement element)
        {
            Optional <string>         kind                  = default;
            ResourceIdentifier        id                    = default;
            string                    name                  = default;
            ResourceType              type                  = default;
            SystemData                systemData            = default;
            Optional <string>         functionAppResourceId = default;
            Optional <string>         functionAppRegion     = default;
            Optional <DateTimeOffset> createdOn             = default;

            foreach (var property in element.EnumerateObject())
            {
                if (property.NameEquals("kind"))
                {
                    kind = property.Value.GetString();
                    continue;
                }
                if (property.NameEquals("id"))
                {
                    id = new ResourceIdentifier(property.Value.GetString());
                    continue;
                }
                if (property.NameEquals("name"))
                {
                    name = property.Value.GetString();
                    continue;
                }
                if (property.NameEquals("type"))
                {
                    type = property.Value.GetString();
                    continue;
                }
                if (property.NameEquals("systemData"))
                {
                    systemData = JsonSerializer.Deserialize <SystemData>(property.Value.ToString());
                    continue;
                }
                if (property.NameEquals("properties"))
                {
                    if (property.Value.ValueKind == JsonValueKind.Null)
                    {
                        property.ThrowNonNullablePropertyIsNull();
                        continue;
                    }
                    foreach (var property0 in property.Value.EnumerateObject())
                    {
                        if (property0.NameEquals("functionAppResourceId"))
                        {
                            functionAppResourceId = property0.Value.GetString();
                            continue;
                        }
                        if (property0.NameEquals("functionAppRegion"))
                        {
                            functionAppRegion = property0.Value.GetString();
                            continue;
                        }
                        if (property0.NameEquals("createdOn"))
                        {
                            if (property0.Value.ValueKind == JsonValueKind.Null)
                            {
                                property0.ThrowNonNullablePropertyIsNull();
                                continue;
                            }
                            createdOn = property0.Value.GetDateTimeOffset("O");
                            continue;
                        }
                    }
                    continue;
                }
            }
            return(new StaticSiteUserProvidedFunctionApp(id, name, type, systemData, kind.Value, functionAppResourceId.Value, functionAppRegion.Value, Optional.ToNullable(createdOn)));
        }
Example #39
0
        /// <summary>
        /// Reads JSON
        /// </summary>
        /// <param name="reader">JSON reader</param>
        /// <param name="objectType">Object type</param>
        /// <param name="existingValue">Existing value</param>
        /// <param name="hasExistingValue">Has existing value</param>
        /// <param name="serializer">JSON serializer</param>
        /// <returns>Language</returns>
        public override ELanguage ReadJson(JsonReader reader, Type objectType, ELanguage existingValue, bool hasExistingValue, JsonSerializer serializer)
        {
            ELanguage ret = existingValue;

            if (reader.Value is string value)
            {
                switch (value)
                {
                case "english_gb":
                    ret = ELanguage.EnglishGB;
                    break;

                case "english":
                    ret = ELanguage.EnglishUS;
                    break;

                default:
                    if (!Enum.TryParse(Naming.UpperFirstCharacter(value), out ret))
                    {
                        ret = ELanguage.Invalid;
                    }
                    break;
                }
            }
            return(ret);
        }
Example #40
0
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
        {
            return(null);
        }
        try
        {
            int defaultCount = 0;
            var contract     = (JsonObjectContract)serializer.ContractResolver.ResolveContract(objectType);
            if (existingValue == null)
            {
                existingValue = contract.DefaultCreator();
            }
            while (reader.Read())
            {
                switch (reader.TokenType)
                {
                case JsonToken.Comment:
                    break;

                case JsonToken.PropertyName:
                {
                    var name     = reader.Value.ToString();
                    var property = contract.Properties.GetClosestMatchProperty(name);
                    if (!reader.Read())
                    {
                        throw new JsonSerializationException(string.Format("Missing value at path: {0}", reader.Path));
                    }
                    if (property == null)
                    {
                        property = contract.Properties.Where(p => p.AttributeProvider.GetAttributes(true).OfType <JsonAnyPropertyNameAttribute>().Any()).Single();
                        defaultCount++;
                        if (defaultCount > 1)
                        {
                            throw new JsonSerializationException(string.Format("Too many properties with unknown names for type {0} at path {1}", objectType, reader.Path));
                        }
                    }
                    var value = serializer.Deserialize(reader, property.PropertyType);
                    property.ValueProvider.SetValue(existingValue, value);
                }
                break;

                case JsonToken.EndObject:
                    return(existingValue);

                default:
                    throw new JsonSerializationException(string.Format("Unknown token {0} at path: {1} ", reader.TokenType, reader.Path));
                }
            }
            throw new JsonSerializationException(string.Format("Unclosed object at path: {0}", reader.Path));
        }
        catch (Exception ex)
        {
            if (ex is JsonException)
            {
                throw;
            }
            // Wrap any exceptions encountered in a JsonSerializationException
            throw new JsonSerializationException(string.Format("Error deserializing type {0} at path {1}", objectType, reader.Path), ex);
        }
    }
Example #41
0
        /// <summary>
        /// Reads the JSON representation of the object.
        /// </summary>
        /// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
        /// <param name="objectType">Type of the object.</param>
        /// <param name="existingValue">The existing value of object being read.</param>
        /// <param name="serializer">The calling serializer.</param>
        /// <returns>The object value.</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            DataSet ds = new DataSet();

            DataTableConverter converter = new DataTableConverter();

            reader.Read();

            while (reader.TokenType == JsonToken.PropertyName)
            {
                DataTable dt = (DataTable)converter.ReadJson(reader, typeof(DataTable), null, serializer);
                ds.Tables.Add(dt);

                reader.Read();
            }

            return(ds);
        }
Example #42
0
 /// <summary>
 /// Writes JSON
 /// </summary>
 /// <param name="writer">JSON writer</param>
 /// <param name="value">Language value</param>
 /// <param name="serializer">JSON serializer</param>
 public override void WriteJson(JsonWriter writer, ELanguage value, JsonSerializer serializer) => writer.WriteValue(Naming.GetLanguageString(value));
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var underlyingObjectType = objectType.GetNotNullableTypeOrOriginal();
            var objectTypeIsNullable = (underlyingObjectType != objectType);

            if (!underlyingObjectType.IsEnum)
            {
                throw new JsonSerializationException(string.Format(
                                                         "Cannot convert value to non-enum {0}",
                                                         objectType));
            }

            if (reader.TokenType == JsonToken.Null)
            {
                if (!objectTypeIsNullable)
                {
                    throw new JsonSerializationException(string.Format(
                                                             "Cannot convert null value to {0}",
                                                             objectType));
                }

                return(null);
            }

            if (reader.TokenType != JsonToken.String)
            {
                throw new JsonSerializationException(string.Format(
                                                         "Cannot convert {0} token to {1}",
                                                         reader.TokenType.ToString(),
                                                         objectType));
            }

            try
            {
                var jsonValue = reader.Value.ToString();

                foreach (var enumValueDeclaration in underlyingObjectType.GetFields(BindingFlags.Public | BindingFlags.Static))
                {
                    var enumValueAttribute = (JsonEnumValueAttribute)enumValueDeclaration
                                             .GetCustomAttributes(typeof(JsonEnumValueAttribute), false)
                                             .FirstOrDefault();

                    if (enumValueAttribute == null)
                    {
                        continue;
                    }

                    if (enumValueAttribute.Value == jsonValue)
                    {
                        return(enumValueDeclaration.GetValue(null));
                    }
                }
            }
            catch (Exception e)
            {
                throw new JsonSerializationException(string.Format(
                                                         "Error parsing value \"{0}\" as {1}",
                                                         reader.Value,
                                                         objectType), e);
            }

            if (IsStrict)
            {
                throw new JsonSerializationException(string.Format(
                                                         "Error parsing value \"{0}\" as {1}",
                                                         reader.Value,
                                                         objectType));
            }
            return(existingValue);
        }
Example #44
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var properties = new PropertiesBag();

            while (reader.Read())
            {
                if (reader.TokenType != JsonToken.PropertyName)
                {
                    break;
                }

                var key = reader.Value.ToString();

                reader.Read();

                var value = reader.Value;

                if (value is DateTime dateTime)
                {
                    properties.Set(key, dateTime.ToInstant());
                }
                else
                {
                    properties.Set(key, value);
                }
            }

            return properties;
        }
Example #45
0
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     writer.WriteValue(value?.ToString());
 }
Example #46
0
        private void GrdResult_CellBeginEdit(object sender, DataGridViewCellCancelEventArgs e)
        {
            var cell = grdResult.Rows[e.RowIndex].Cells[e.ColumnIndex];

            cell.Value = JsonSerializer.Serialize(cell.Tag as BsonValue);
        }
Example #47
0
            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                User user = (User)value;

                writer.WriteValue(user.UserName);
            }
Example #48
0
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) =>
 reader.Value == null ? null : ConvertFromString((string)reader.Value, objectType);
Example #49
0
 public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 {
     throw new NotImplementedException();
 }
Example #50
0
            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                User user = new User();

                user.UserName = (string)reader.Value;

                return(user);
            }
Example #51
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var constructor = objectType.GetConstructor(Type.EmptyTypes);
            var instance    = constructor.Invoke(null);

            if (reader.ValueType.IsSimple())
            {
                return(reader.Value);
            }

            var properties = objectType.GetProperties().ToDictionary(x => this.Simplify(x.Name), x => x);

            foreach (var jProperty in JObject.Load(reader).Properties())
            {
                var property = this.FindBestMatch(properties, jProperty.Name, 3);
                if (property == null)
                {
                    continue;
                }

                if (property.PropertyType.IsArray && !(jProperty.Value is JArray))
                {
                    this.ParseDictionaryAsListByType(
                        property.PropertyType.GetElementType(),
                        jProperty,
                        serializer,
                        property,
                        instance
                        );
                }
                else
                {
                    property.SetValue(instance, jProperty.Value.ToObject(property.PropertyType, serializer));
                }
            }
            return(instance);
        }
        /// <summary>
        /// Dies Methode hält die Kommuniktion mit dem Client aufrecht, um den Synchronisierungsfortschritt
        /// pro Foto in den Ausgabefluss zu schreiben
        /// </summary>
        /// <param name="stream">Der Stream mit dem Client</param>
        /// <param name="content">Der Inhalt des Streams. Wird nicht verwendet, ist aber für den Aufruf erfordern</param>
        /// <param name="context">Der Context der Verbindung. Wird nicht verwendet, ist aber für den Aufruf erfordern</param>
        /// <remarks>Es ist nicht sichergestellt, dass die Verbindung offen bleibt. Außerdem ist unklar wie die Browser auf den
        /// Flush reaagieren, so dass das Parsen der einzelnen Fortschirttinformatioen <see cref="SynchProgress"/> nicht klar ist</remarks>
        public void OnStreamAvailable(Stream stream, HttpContent content, TransportContext context)
        {
            try
            {
                var serializer = new JsonSerializer();
                var memberId = GetMemberId();
                bool streamIsOpen = true;
                foreach (var currentStep in _connector.RefreshFolderContent())
                {
                    try
                    {
                        NotificationHub.PushNotification(new Notification()
                        {
                            Data = currentStep,
                            Type = NotificationType.PhotoSynch,
                            Date = DateTime.Now,
                            MemberId = memberId,
                            PhotoName = currentStep.Photo == null ? string.Empty : currentStep.Photo.Name,
                            PhotoTitle  = currentStep.Photo == null ? string.Empty : currentStep.Photo.Title 
                        });

                        if (currentStep.Photo != null)
                        {
                            SavePhotosToDatabase(currentStep.Photo);
                        }

                        if (!streamIsOpen) continue;

                        using (var writer = new StreamWriter(stream))
                        {
                            if (currentStep.Photo != null)
                            {
                                dynamic currentPhoto = new
                                {
                                    currentStep.Photo.Id,
                                    currentStep.Photo.Title,
                                    currentStep.Photo.Name,
                                    currentStep.Photo.OriginalName,
                                    currentStep.Photo.MemberId,
                                    currentStep.Photo.IsPrivate,
                                    DirectLinks = currentStep.Photo.DirectLinks.Where(l => l.Size <= 400).ToList(),
                                    currentStep.Photo.Color
                                };
                                dynamic progress = new
                                {
                                    currentStep.TotalFileCount,
                                    currentStep.Index,
                                    Photo = currentPhoto
                                };
                                var returnValue = new Result<object>() { Data = progress };
                                serializer.Serialize(writer, returnValue);
                            }
                            else
                            {
                                var returnValue = new Result<SynchProgress> { Data = currentStep };
                                serializer.Serialize(writer, returnValue);
                            }
                            stream.Flush();
                        }
                    }

                    catch (HttpException ex)
                    {
                        // Die Verbindung zum Client wurde unterbrochen, die Synchronisierung läuft jedoch weiter
                        if (ex.ErrorCode == -2147023667)
                        {
                            streamIsOpen = false;
                        }
                    }
                }
                var notification = new Notification()
                {
                    Type = NotificationType.PhotoSynch,
                    MemberId = memberId,
                    UserAlias = "fotosteam"
                };
                DataRepository.Add(notification);
            }
            catch (Exception ex)
            {
                Log.Error(ex);
                var error = new Result<SynchProgress> { Data = new SynchProgress() };
                error.Status.Code = Controller.StatusCode.Failure;
                error.Status.Message = ResultMessages.UnhandledException;
                try
                {
                    using (var writer = new StreamWriter(stream))
                    {
                        var serializer = new JsonSerializer();
                        serializer.Serialize(writer, error);

                    }
                }
                catch (Exception ex1)
                {
                    //Da können wir jetzt auch nicht mehr machen.
                    Log.Error(ex1);
                }

            }
            finally
            {
                // Close output stream as we are done
                stream.Close();
            }
        }
Example #53
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.Value is string vs)
            {
                return new List <string> {
                           vs
                }
            }
            ;
            else if (reader.Value is int vi)
            {
                return new List <string> {
                           vi.ToString()
                }
            }
            ;
            else if (reader.Value is long vl)
            {
                return new List <string> {
                           vl.ToString()
                }
            }
            ;
            else
            {
                var list = serializer.Deserialize <List <string> >(reader);

                return(list.Count < 1 ? null : list);
            }
        }
Example #54
0
 private void ParseDictionaryAsListByType(Type elementType, JProperty jp, JsonSerializer serializer, PropertyInfo prop, object instance)
 => this.InvokePrivateGeneric <object>(nameof(ParseDictionaryAsList), elementType, jp, serializer, prop, instance);
Example #55
0
 /// <summary>
 /// Writes the value of the parameters to json format
 /// </summary>
 /// <param name="writer">Json writer</param>
 /// <param name="value">Value to be converted to json format</param>
 /// <param name="serializer">Json serializer</param>
 public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
 {
     serializer.Serialize(writer, value);
 }
Example #56
0
        public async Task <CustomerBasket> GetBasketAsync(string basketId)
        {
            var data = await _database.StringGetAsync(basketId);

            return(data.IsNullOrEmpty ? null : JsonSerializer.Deserialize <CustomerBasket>(data));
        }
Example #57
0
        public sealed override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            bool existingIsNull = existingValue == null;

            if (!(existingIsNull || existingValue is T))
            {
                throw new JsonSerializationException($"Converter cannot read JSON with the specified existing value. {typeof(T)} is required.");
            }

            return(ReadJson(reader, objectType, existingIsNull ? default : (T)existingValue, !existingIsNull, serializer));
        }
Example #58
0
        /// <summary>
        /// Read the json format and return the correct object type/value for it
        /// </summary>
        /// <param name="reader">Json reader</param>
        /// <param name="objectType">Type of property being set</param>
        /// <param name="existingValue">The current value of the property being set</param>
        /// <param name="serializer">Json serializer</param>
        /// <returns>The object value of the converted json value</returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            switch (reader.TokenType)
            {
            case JsonToken.StartObject:
                try
                {
                    JObject jObject = JObject.Load(reader);
                    return(jObject.ToObject <Dictionary <string, object> >());
                }
                catch (Exception)
                {
                    throw new Exception("Request parameters can only be an associative array, list or null.");
                }

            case JsonToken.StartArray:
                return(JArray.Load(reader).ToObject <object[]>(serializer));

            case JsonToken.Null:
                return(null);
            }
            throw new Exception("Request parameters can only be an associative array, list or null.");
        }
Example #59
0
 public abstract void WriteJson(JsonWriter writer, T value, JsonSerializer serializer);
Example #60
0
 public abstract T ReadJson(JsonReader reader, Type objectType, T existingValue, bool hasExistingValue, JsonSerializer serializer);