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());
}
