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