public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { try { var typedValue = value; if (value is IJsonValue jsonValue) { if (jsonValue.Type == JsonValueType.Null) { typedValue = null; } else { typedValue = JsonValueConverter.ConvertValue(field, jsonValue); } } if (validators?.Length > 0) { var tasks = new List <Task>(); foreach (var validator in validators) { tasks.Add(validator.ValidateAsync(typedValue, context, addError)); } await Task.WhenAll(tasks); } } catch { addError(context.Path, "Not a valid value."); } }
public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { try { object typedValue = null; if (value is JToken jToken) { typedValue = jToken.IsNull() ? null : JsonValueConverter.ConvertValue(field, jToken); } var tasks = new List <Task>(); foreach (var validator in validators) { tasks.Add(validator.ValidateAsync(typedValue, context, addError)); } await Task.WhenAll(tasks); } catch { addError(context.Path, "Not a valid value."); } }
public static FieldConverter ExcludeChangedTypes() { return((data, field) => { var isValid = true; foreach (var value in data.Values) { try { if (!value.IsNull()) { JsonValueConverter.ConvertValue(field, value); } } catch { isValid = false; break; } } if (!isValid) { return null; } return data; }); }
public async ValueTask ValidateAsync(object?value, ValidationContext context, AddError addError) { var typedValue = value; try { if (value is IJsonValue jsonValue) { if (jsonValue.Type == JsonValueType.Null) { typedValue = null; } else { var(json, error) = JsonValueConverter.ConvertValue(field, jsonValue, context.JsonSerializer, context.Components); if (error != null) { addError(context.Path, error.Error); } else { typedValue = json; } } } } catch { addError(context.Path, T.Get("contents.validation.invalid")); return; } await validator.ValidateAsync(typedValue, context, addError); }
public static void Map(ModelBuilder modelBuilder) { var enumConverter = new EnumToStringConverter <Scope>(); var jsonListStringConverter = new JsonValueConverter <IEnumerable <string> >(); var jsonConfigConverter = new JsonValueConverter <Config>(); modelBuilder.Entity <UserEntity>() .Property(e => e.Scope) .HasConversion(enumConverter); modelBuilder.Entity <UserEntity>() .Property(e => e.Aliases) .HasConversion(jsonListStringConverter) .HasJsonComparer(); modelBuilder.Entity <UserEntity>() .HasOne(u => u.Branch) .WithMany(b => b.Users) .OnDelete(DeleteBehavior.Restrict); modelBuilder.Entity <UserEntity>() .Property(u => u.UserTypeId) .HasDefaultValueSql($"'{UserType.BROKER.ToString()}'"); modelBuilder.Entity <UserEntity>() .Property(e => e.Config) .HasConversion(jsonConfigConverter) .HasDefaultValueSql("'{ }'"); }
public void CheckJsonConversation() { var testSubject = new Test() { numberValue = JsonValue.NewNumber(5), stringValue = JsonValue.NewString("abc"), nullValue = JsonValue.Null, dateLikeString = JsonValue.NewString(DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ")), arrayOfObjectsValue = JsonValue.NewArray( new[] { JsonValue.NewNumber(10), JsonValue.NewRecord(new [] { Tuple.Create("propA", JsonValue.NewNumber(5)), Tuple.Create("propB", JsonValue.NewNumber(10)) }), JsonValue.Null, JsonValue.NewArray(new [] { JsonValue.NewNumber(10) }) } ) }; var converter = new JsonValueConverter(); var target = JsonConvert.DeserializeObject <Test>(JsonConvert.SerializeObject(testSubject, converter), converter); Assert.Equal(testSubject.numberValue, target.numberValue); Assert.Equal(testSubject.stringValue, target.stringValue); Assert.Equal(testSubject.nullValue, target.nullValue); Assert.Equal(testSubject.arrayOfObjectsValue, target.arrayOfObjectsValue); Assert.Equal(testSubject.dateLikeString, target.dateLikeString); }
public static ValueConverter ExcludeChangedTypes(IJsonSerializer jsonSerializer) { return((value, field, parent) => { if (value.Type == JsonValueType.Null) { return value; } try { var(_, error) = JsonValueConverter.ConvertValue(field, value, jsonSerializer); if (error != null) { return null; } } catch { return null; } return value; }); }
public static FieldConverter ExcludeChangedTypes() { return((data, field) => { foreach (var value in data.Values) { if (value.Type == JsonValueType.Null) { continue; } try { var(_, error) = JsonValueConverter.ConvertValue(field, value); if (error != null) { return null; } } catch { return null; } } return data; }); }
public static ValueConverter ExcludeChangedTypes() { return((value, field) => { if (value.Type == JsonValueType.Null) { return value; } try { var(_, error) = JsonValueConverter.ConvertValue(field, value); if (error != null) { return Value.Unset; } } catch { return Value.Unset; } return value; }); }
public static void Map(ModelBuilder modelBuilder) { var jsonConverter = new JsonValueConverter <dynamic>(); modelBuilder.Entity <AuditLogEntity>() .Property(e => e.Data) .HasConversion(jsonConverter); }
public static void Map(ModelBuilder modelBuilder) { var jsonConverter = new JsonValueConverter <Config>(); modelBuilder.Entity <CommissionStatementTemplateEntity>() .Property(e => e.Config) .HasConversion(jsonConverter); }
public static void Map(ModelBuilder modelBuilder) { var jsonConverter = new JsonValueConverter <ImportCommission>(); modelBuilder.Entity <CommissionErrorEntity>() .Property(e => e.Data) .HasConversion(jsonConverter); }
public static void Map(ModelBuilder modelBuilder) { var jsonConverter = new JsonValueConverter <List <CommissionSplit> >(); modelBuilder.Entity <CommissionSplitRuleEntity>() .Property(c => c.Split) .HasConversion(jsonConverter) .HasJsonComparer(); }
public static void Map(ModelBuilder modelBuilder) { var jsonConverter = new JsonValueConverter <IEnumerable <string> >(); modelBuilder.Entity <CompanyEntity>() .Property(e => e.CommissionPolicyNumberPrefixes) .HasConversion(jsonConverter) .HasJsonComparer(); }
// If this method is changed, also change JsonPropertyInfoNullable.ReadEnumerable and JsonSerializer.ApplyObjectToEnumerable public override void ReadEnumerable(JsonTokenType tokenType, ref ReadStack state, ref Utf8JsonReader reader) { Debug.Assert(ShouldDeserialize); if (state.Current.KeyName == null && (state.Current.IsProcessingDictionary || state.Current.IsProcessingIDictionaryConstructibleOrKeyValuePair)) { ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath); return; } // We need an initialized array in order to store the values. if (state.Current.IsProcessingEnumerable && state.Current.TempEnumerableValues == null && state.Current.ReturnValue == null) { ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath); return; } if (ValueConverter == null || !ValueConverter.TryRead(RuntimePropertyType, ref reader, out TRuntimeProperty value)) { if (state.Current.IsProcessingKeyValuePair && state.Current.KeyName == "Key") { // Handle the special case where the input KeyValuePair is of form {"Key": "MyKey", "Value": 1} // (as opposed to form {"MyKey": 1}) and the value type is not string. // If we have one, the ValueConverter failed to read the current token because it should be of type string // (we only support string keys) but we initially tried to read it as type TRuntimeProperty. // We have TRuntimeProperty not string because for deserialization, we parse the KeyValuePair as a // dictionary before creating a KeyValuePair instance in a converter-like manner with the parsed values. // Because it's dictionary-like parsing, we set the element type of the dictionary earlier on to the KeyValuePair's value // type, which led us here. // If there's no ValueConverter, the runtime type of the KeyValuePair's value is probably an object, dictionary or enumerable. JsonValueConverter <string> stringConverter = DefaultConverters <string> .s_converter; if (!stringConverter.TryRead(typeof(string), ref reader, out string strValue)) { ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(typeof(string), reader, state.JsonPath); } object objValue = strValue; JsonSerializer.ApplyValueToEnumerable(ref objValue, ref state, ref reader); return; } ThrowHelper.ThrowJsonException_DeserializeUnableToConvertValue(RuntimePropertyType, reader, state.JsonPath); return; } if (state.Current.IsProcessingKeyValuePair) { // The value is being applied to a Dictionary<string, object>, so we need to cast to object here. object objValue = value; JsonSerializer.ApplyValueToEnumerable(ref objValue, ref state, ref reader); return; } JsonSerializer.ApplyValueToEnumerable(ref value, ref state, ref reader); }
public void ReadJsonNullValue() { string json = "null"; JsonTextReader writer = new JsonTextReader(new StringReader(json)); JsonValueConverter converter = new JsonValueConverter(); JsonValue v = (JsonValue)converter.ReadJson(writer, typeof(JsonValue), null, null); Assert.AreEqual(JsonValueType.Null, v.ValueType); }
public void WhenDeserializedContainsExpectedValue() { var converter = new JsonValueConverter <Person>(); var deserialized = (Person)converter.ConvertFromProvider(_json); deserialized.Should().NotBeNull(); deserialized.Name.Should().Be("John Smith"); deserialized.Address.Should().NotBeNull(); deserialized.Address.AddressLine1.Should().Be("1 Some Street"); }
public void WhenSerializedContainsExpectedValue() { var person = new Person { Name = "John Smith", Address = new Address { AddressLine1 = "1 Some Street" } }; var converter = new JsonValueConverter <Person>(); var serialized = (string)converter.ConvertToProvider(person); serialized.Should().BeEquivalentTo(_json, serialized); }
public void ReadJsonUnexpectedEndInArray() { string json = "["; JsonTextReader writer = new JsonTextReader(new StringReader(json)); JsonValueConverter converter = new JsonValueConverter(); ExceptionAssert.Throws <JsonException>(() => { converter.ReadJson(writer, typeof(JsonValue), null, null); }, "Unexpected end when reading JSON. Path '', line 1, position 1."); }
public static void Map(ModelBuilder modelBuilder) { var jsonConverter = new JsonValueConverter <IEnumerable <string> >(); modelBuilder.Entity <PolicyEntity>() .Property(p => p.Premium) .HasColumnType("Money"); modelBuilder.Entity <PolicyEntity>() .Property(e => e._NumberAliases) .HasColumnName("NumberAliases") .HasDefaultValueSql("'[]'"); }
public void ReadJsonUnsupportedValue() { string json = "undefined"; JsonTextReader writer = new JsonTextReader(new StringReader(json)); JsonValueConverter converter = new JsonValueConverter(); ExceptionAssert.Throws <JsonException>(() => { converter.ReadJson(writer, typeof(JsonValue), null, null); }, "Unexpected or unsupported token: Undefined. Path '', line 1, position 9."); }
public void ReadJsonBadJsonType() { string json = "null"; JsonTextReader writer = new JsonTextReader(new StringReader(json)); JsonValueConverter converter = new JsonValueConverter(); ExceptionAssert.Throws <JsonException>(() => { converter.ReadJson(writer, typeof(JsonObject), null, null); }, "Could not convert 'Windows.Data.Json.JsonValue' to 'Windows.Data.Json.JsonObject'. Path '', line 1, position 4."); }
public void ReadJsonUnexpectedEndInObject() { string json = "{'hi':"; JsonTextReader writer = new JsonTextReader(new StringReader(json)); JsonValueConverter converter = new JsonValueConverter(); ExceptionAssert.Throws <JsonException>(() => { converter.ReadJson(writer, typeof(JsonValue), null, null); }, "Unexpected end. Path 'hi', line 1, position 6."); }
public void ReadJsonUnexpectedEndAfterComment() { string json = "[/*comment!*/"; JsonTextReader writer = new JsonTextReader(new StringReader(json)); JsonValueConverter converter = new JsonValueConverter(); ExceptionAssert.Throws <JsonException>(() => { converter.ReadJson(writer, typeof(JsonValue), null, null); }, "Unexpected end. Path '', line 1, position 13."); }
public static void Map(ModelBuilder modelBuilder) { var jsonConfigConverter = new JsonValueConverter <Config>(); var jsonListConverter = new JsonValueConverter <IEnumerable <Guid> >(); modelBuilder.Entity <OrganisationEntity>() .Property(e => e.Config) .HasConversion(jsonConfigConverter) .HasDefaultValueSql("'{ }'"); modelBuilder.Entity <OrganisationEntity>() .Property(u => u.ApplicationIds) .HasConversion(jsonListConverter) .HasDefaultValueSql("'[]'"); }
internal static void WriteDictionary <TProperty>( JsonValueConverter <TProperty> converter, JsonSerializerOptions options, ref WriteStackFrame current, Utf8JsonWriter writer) { if (converter == null) { return; } Debug.Assert(current.Enumerator != null); string key; TProperty value; if (current.Enumerator is IEnumerator <KeyValuePair <string, TProperty> > enumerator) { // Avoid boxing for strongly-typed enumerators such as returned from IDictionary<string, TRuntimeProperty> value = enumerator.Current.Value; key = enumerator.Current.Key; } else if (current.Enumerator is IEnumerator <KeyValuePair <string, object> > polymorphicEnumerator) { value = (TProperty)polymorphicEnumerator.Current.Value; key = polymorphicEnumerator.Current.Key; } else if (current.IsImmutableDictionary || current.IsImmutableDictionaryProperty) { value = (TProperty)((DictionaryEntry)current.Enumerator.Current).Value; key = (string)((DictionaryEntry)current.Enumerator.Current).Key; } else { // Todo: support non-generic Dictionary here (IDictionaryEnumerator) throw new NotSupportedException(); } if (value == null) { writer.WriteNull(key); } else { JsonEncodedText escapedKey = JsonEncodedText.Encode(key); converter.Write(escapedKey, value, writer); } }
public void ApplyCustomJsonConverter() { var customer = new Customer { ProtectedAddress = new Address { Street = "Privet Drive 4" } }; var converter = new JsonValueConverter <Customer>(); var serialized = (string)converter.ConvertToProvider(customer); Assert.IsFalse(serialized.Contains("Privet"), "Serialization applied custom converter"); var deserialized = (Customer)converter.ConvertFromProvider(serialized); Assert.AreEqual("Privet Drive 4", deserialized.ProtectedAddress.Street, "Deserialization applied custom converter"); }
public async Task ValidateAsync(object?value, ValidationContext context, AddError addError) { var typedValue = value; try { if (value is IJsonValue jsonValue) { if (jsonValue.Type == JsonValueType.Null) { typedValue = null; } else { var(json, error) = JsonValueConverter.ConvertValue(field, jsonValue); if (error != null) { addError(context.Path, error.Error); } else { typedValue = json; } } } } catch { addError(context.Path, T.Get("contents.validation.invalid")); return; } if (validators?.Length > 0) { var tasks = new List <Task>(); foreach (var validator in validators) { tasks.Add(validator.ValidateAsync(typedValue, context, addError)); } await Task.WhenAll(tasks); } }
public static void Map(ModelBuilder modelBuilder) { var jsonConverter = new JsonValueConverter <ImportCommission>(); modelBuilder.Entity <CommissionEntity>() .Property(p => p.AmountIncludingVAT) .HasColumnType("Money"); modelBuilder.Entity <CommissionEntity>() .Property(p => p.VAT) .HasColumnType("Money"); modelBuilder.Entity <CommissionEntity>() .Property(e => e.SourceData) .HasConversion(jsonConverter); modelBuilder.Entity <CommissionEntity>() .HasIndex(c => new { c.UserId, c.CommissionStatementId, c.CommissionTypeId, c.PolicyId }) .HasName("INDEX_Commission_UserId_CommissionStatementId"); }
public void ReadJson() { string json = @"{ ""CPU"": ""Intel"", ""Drives"": [ ""DVD read/writer"", ""500 gigabyte hard drive"" ] }"; JsonTextReader writer = new JsonTextReader(new StringReader(json)); JsonValueConverter converter = new JsonValueConverter(); JsonObject o = (JsonObject)converter.ReadJson(writer, typeof(JsonObject), null, null); Assert.AreEqual(2, o.Count); Assert.AreEqual("Intel", o.GetNamedString("CPU")); Assert.AreEqual("DVD read/writer", o.GetNamedArray("Drives")[0].GetString()); Assert.AreEqual("500 gigabyte hard drive", o.GetNamedArray("Drives")[1].GetString()); }