private static IJsonValue?ConvertComponents(IJsonValue?value, ValueConverter[] converters,
ResolvedComponents components)
{
if (value is JsonArray array)
{
JsonArray?result = null;
for (int i = 0, j = 0; i < array.Count; i++, j++)
{
var newValue = ConvertComponent(array[i], converters, components);
if (newValue == null)
{
result ??= new JsonArray(array);
result.RemoveAt(j);
j--;
}
else if (!ReferenceEquals(newValue, array[i]))
{
result ??= new JsonArray(array);
result[j] = newValue;
}
}
return(result ?? array);
}
return(null);
}
public static JsValue Map(IJsonValue?value, Engine engine)
{
if (value == null)
{
return(JsValue.Null);
}
switch (value)
{
case JsonNull:
return(JsValue.Null);
case JsonString s:
return(new JsString(s.Value));
case JsonBoolean b:
return(new JsBoolean(b.Value));
case JsonNumber b:
return(new JsNumber(b.Value));
case JsonObject obj:
return(FromObject(obj, engine));
case JsonArray arr:
return(FromArray(arr, engine));
}
throw new ArgumentException("Invalid json type.", nameof(value));
}
private static JsonObject ParseObject(this IJsonReader reader)
{
var obj = new JsonObject();
while (reader.Read() != Json.Token.EndOfFile)
{
if (reader.CurrentToken == Json.Token.ObjectStart)
{
continue;
}
if (reader.CurrentToken == Json.Token.ObjectKey)
{
string?Key = (string?)reader.CurrentValue;
if (Key != null)
{
IJsonValue?Value = reader.ParseValue();
obj.Add(Key, Value);
}
}
else if (reader.CurrentToken == Json.Token.ObjectEnd)
{
break;
}
}
return(obj);
}
public void Should_resolve_from_fallback_language_if_found(IJsonValue?value)
{
var field = Fields.String(1, "string", Partitioning.Language);
var config =
LanguagesConfig.English
.Set(Language.DE)
.Set(Language.IT)
.Set(Language.ES, false, Language.IT);
var source =
new ContentFieldData()
.AddLocalized("en", "EN")
.AddLocalized("it", "IT");
if (value != JsonValue.False)
{
source["de"] = value !;
}
var expected =
new ContentFieldData()
.AddLocalized("en", "EN")
.AddLocalized("it", "IT")
.AddLocalized("es", "IT")
.AddLocalized("de", "EN");
var result = FieldConverters.ResolveFallbackLanguages(config)(source, field);
Assert.Equal(expected, result);
}
public static FieldConverter ForValues(params ValueConverter[] converters)
{
return((data, field) =>
{
foreach (var(key, value) in data.ToList())
{
IJsonValue?newValue = value;
for (var i = 0; i < converters.Length; i++)
{
newValue = converters[i](newValue !, field, null);
if (newValue == null)
{
break;
}
}
if (newValue == null)
{
data.Remove(key);
}
else if (!ReferenceEquals(newValue, value))
{
data[key] = newValue;
}
}
return data;
});
}
private static IJsonValue?ConvertComponent(IField field, IJsonValue?value, ValueConverter[] converters)
{
if (value is JsonObject obj && obj.TryGetValue <JsonString>(Component.Discriminator, out var type) && field.TryGetResolvedSchema(type.Value, out var schema))
{
return(ConvertNested(schema.FieldCollection, obj, null, converters));
}
return(null);
}
private static IJsonValue?ConvertArrayItem(IArrayField field, IJsonValue?value, ValueConverter[] converters)
{
if (value is JsonObject obj)
{
return(ConvertNested(field.FieldCollection, obj, field, converters));
}
return(null);
}
public static IJsonValue Parse(this IJsonReader reader)
{
if (reader.Read() == Json.Token.EndOfFile)
{
return(new JsonObject());
}
else if (reader.CurrentToken == Json.Token.ObjectKey)
{
JsonObject Object = new JsonObject();
string?Key = (string?)reader.CurrentValue;
if (Key != null)
{
IJsonValue?Value = reader.ParseValue();
Object.Add(Key, Value);
}
return(Object);
}
else if (reader.CurrentToken == Json.Token.ArrayStart)
{
JsonValueCollection Array = new JsonValueCollection();
while (reader.CurrentToken != Json.Token.EndOfFile)
{
IJsonValue?Value = reader.ParseValue();
if (reader.CurrentToken == Json.Token.ArrayEnd)
{
if (Array.Count > 0 || !(Value is JsonValueCollection))
{
break;
}
else
{
if (Array.Count > 0 || !(Value is JsonValueCollection))
{
break;
}
}
}
if (Value != null)
{
Array.Add(Value);
}
}
return(Array);
}
else
{
return(reader.ParseObject());
}
}
public static string Format(IJsonValue?value, IField field)
{
Guard.NotNull(field);
if (value == null || value is JsonNull)
{
return(string.Empty);
}
return(field.Accept(new StringFormatter(value)));
}
public static HashSet <DomainId> GetReferencedIds(this IField field, IJsonValue?value, int referencesPerField = int.MaxValue)
{
var result = new HashSet <DomainId>();
if (value != null)
{
ReferencesExtractor.Extract(field, value, result, referencesPerField);
}
return(result);
}
public static void AddIds(this IJsonValue?value, HashSet <Guid> result)
{
if (value is JsonArray array)
{
foreach (var id in array)
{
if (id.Type == JsonValueType.String && Guid.TryParse(id.ToString(), out var guid))
{
result.Add(guid);
}
}
}
}
public static string Format(IField field, IJsonValue?value)
{
Guard.NotNull(field, nameof(field));
if (value == null || value is JsonNull)
{
return(string.Empty);
}
var args = new Args(value ?? JsonValue.Null);
return(field.RawProperties.Accept(Instance, args));
}
public static ValueConverter ForNested(params ValueConverter[] converters)
{
if (converters?.Any() != true)
{
return(Noop);
}
return((value, field, parent) =>
{
if (value is JsonArray array && field is IArrayField arrayField)
{
foreach (var nested in array.OfType <JsonObject>())
{
foreach (var(fieldName, nestedValue) in nested.ToList())
{
IJsonValue?newValue = nestedValue;
if (arrayField.FieldsByName.TryGetValue(fieldName, out var nestedField))
{
for (var i = 0; i < converters.Length; i++)
{
newValue = converters[i](newValue !, nestedField, arrayField);
if (newValue == null)
{
break;
}
}
}
else
{
newValue = null;
}
if (newValue == null)
{
nested.Remove(fieldName);
}
else if (!ReferenceEquals(nestedValue, newValue))
{
nested[fieldName] = newValue;
}
}
}
}
return value;
});
}
public static HashSet <Guid> GetReferencedIds(this IField field, IJsonValue?value)
{
var result = new HashSet <Guid>();
if (value != null)
{
var extractor = new ReferencesExtractor(result);
extractor.SetValue(value);
field.Accept(extractor);
}
return(result);
}
public static HashSet <DomainId> GetReferencedIds(this IField field, IJsonValue?value, int referencesPerField = int.MaxValue)
{
var result = new HashSet <DomainId>();
if (value != null)
{
var extractor = new ReferencesExtractor(result, referencesPerField);
extractor.SetValue(value);
field.Accept(extractor);
}
return(result);
}
private static IJsonValue?ConvertValue(IField field, IJsonValue?value, IArrayField?parent, ValueConverter[] converters)
{
var newValue = value;
for (var i = 0; i < converters.Length; i++)
{
newValue = converters[i](newValue !, field, parent);
if (newValue == null)
{
break;
}
}
return(newValue);
}
private static IJsonValue?ConvertByType <T>(T field, IJsonValue?value, IArrayField?parent, ValueConverter[] converters) where T : IField
{
switch (field)
{
case IArrayField arrayField:
return(ConvertArray(arrayField, value, converters));
case IField <ComponentFieldProperties> :
return(ConvertComponent(field, value, converters));
case IField <ComponentsFieldProperties> :
return(ConvertComponents(field, value, converters));
default:
return(ConvertValue(field, value, parent, converters));
}
}
public static bool TryGetByPath(this IJsonValue?value, IEnumerable <string>?path, [MaybeNullWhen(false)] out IJsonValue result)
{
result = value !;
if (path != null)
{
foreach (var pathSegment in path)
{
if (result == null || !result.TryGet(pathSegment, out result !))
{
break;
}
}
}
return(result != null && !ReferenceEquals(result, value));
}
public static HashSet <Guid> ToGuidSet(this IJsonValue?value)
{
if (value is JsonArray array)
{
var result = new HashSet <Guid>();
foreach (var id in array)
{
if (id.Type == JsonValueType.String && Guid.TryParse(id.ToString(), out var guid))
{
result.Add(guid);
}
}
return(result);
}
return(new HashSet <Guid>());
}
private static IJsonValue?ConvertComponent(IJsonValue?value, ValueConverter[] converters,
ResolvedComponents components)
{
if (value is JsonObject obj && obj.TryGetValue <JsonString>(Component.Discriminator, out var type))
{
var id = DomainId.Create(type.Value);
if (components.TryGetValue(id, out var schema))
{
return(ConvertNested(schema.FieldCollection, obj, null, converters, components));
}
else
{
return(obj);
}
}
return(null);
}
public static void AddIds(this IJsonValue?value, HashSet <Guid> result, int take)
{
var added = 0;
if (value is JsonArray array)
{
foreach (var id in array)
{
if (id.Type == JsonValueType.String && Guid.TryParse(id.ToString(), out var guid))
{
result.Add(guid);
added++;
if (added >= take)
{
break;
}
}
}
}
}
public void Should_resolve_invariant_from_master_language(IJsonValue?value)
{
var field = Fields.String(1, "string", Partitioning.Invariant);
var source =
new ContentFieldData()
.AddLocalized("de", "DE")
.AddLocalized("en", "EN");
if (value != JsonValue.False)
{
source[InvariantPartitioning.Key] = value !;
}
var expected =
new ContentFieldData()
.AddInvariant("EN");
var result = FieldConverters.ResolveInvariant(languagesConfig)(source, field);
Assert.Equal(expected, result);
}
public void Should_resolve_master_language_from_invariant(IJsonValue?value)
{
var field = Fields.String(1, "string", Partitioning.Language);
var source =
new ContentFieldData()
.AddLocalized("iv", "A")
.AddLocalized("it", "B");
if (value != JsonValue.False)
{
source["en"] = value !;
}
var expected =
new ContentFieldData()
.AddLocalized("en", "A");
var result = FieldConverters.ResolveLanguages(languagesConfig)(source, field);
Assert.Equal(expected, result);
}
public static void AddIds(this IJsonValue?value, HashSet <DomainId> result, int take)
{
var added = 0;
if (value is JsonArray array)
{
foreach (var id in array)
{
if (id is JsonString s)
{
result.Add(DomainId.Create(s.Value));
added++;
if (added >= take)
{
break;
}
}
}
}
}
private static void Value(this IJsonWriter writer, IJsonValue?value)
{
if (value == null)
{
writer.Value(null);
}
else if (value.Type == Json.Type.Object)
{
writer.Object((JsonObject)value);
}
else if (value.Type == Json.Type.Array)
{
writer.ArrayStart();
JsonValueCollection ArrayValue = (JsonValueCollection)value;
foreach (IJsonValue ChildValue in ArrayValue)
{
writer.Value(ChildValue);
}
writer.ArrayEnd();
}
else if (value.Type == Json.Type.String)
{
writer.Value(((JsonString)value).String);
}
else if (value.Type == Json.Type.Integer)
{
writer.Value(((JsonInteger)value).Number);
}
else if (value.Type == Json.Type.Float)
{
writer.Value(((JsonFloat)value).Number);
}
else if (value.Type == Json.Type.Boolean)
{
writer.Value(((JsonBool)value).Value);
}
}
public bool Equals(IJsonValue?other)
{
return(Equals(other as JsonArray));
}
public bool Equals(IJsonValue?other)
{
return(Equals(other as JsonScalar <T>));
}
public ContentFieldProperty(ContentFieldObject contentField, IJsonValue?contentValue = null)
{
this.contentField = contentField;
this.contentValue = contentValue;
}
public static IJsonValue Cleanup(IField field, IJsonValue?value, HashSet <DomainId> validIds)
{
var args = new Args(value ?? JsonValue.Null, validIds);
return(field.Accept(Instance, args));
}
public static None Extract(IField field, IJsonValue?value, HashSet <DomainId> result, int take)
{
var args = new Args(value ?? JsonValue.Null, result, take);
return(field.Accept(Instance, args));
}