public static IdContentData ToMongoModel(this NamedContentData result, Schema schema)
{
return(result.ConvertName2Id(schema,
FieldConverters.ForValues(
ValueConverters.EncodeJson()),
FieldConverters.ForNestedName2Id(
ValueConverters.EncodeJson())));
}
public static NamedContentData FromMongoModel(this IdContentData result, Schema schema, IJsonSerializer serializer)
{
return(result.ConvertId2Name(schema,
FieldConverters.ForValues(
ValueConverters.DecodeJson(serializer)),
FieldConverters.ForNestedId2Name(
ValueConverters.DecodeJson(serializer))));
}
public static NamedContentData FromMongoModel(this IdContentData result, Schema schema, List <Guid> deletedIds)
{
return(result.ConvertId2Name(schema,
FieldConverters.ForValues(
ValueConverters.DecodeJson(),
ValueReferencesConverter.CleanReferences(deletedIds)),
FieldConverters.ForNestedId2Name(
ValueConverters.DecodeJson(),
ValueReferencesConverter.CleanReferences(deletedIds))));
}
public void Should_filter_for_value_conversion()
{
var input =
new ContentFieldData()
.AddValue("iv", JsonValue.Object());
var actual = FieldConverters.ForValues((f, i) => Value.Unset)(input, stringInvariantField);
var expected = new ContentFieldData();
Assert.Equal(expected, actual);
}
private IEnumerable <FieldConverter> GenerateConverters(Context context, ValueConverter?cleanReferences)
{
if (!context.IsFrontendClient)
{
yield return(excludedHiddenField);
yield return(excludedHiddenValue);
}
yield return(excludedChangedField);
yield return(excludedChangedValue);
if (cleanReferences != null)
{
yield return(FieldConverters.ForValues(cleanReferences));
yield return(FieldConverters.ForValues(ValueConverters.ForNested(cleanReferences)));
}
yield return(FieldConverters.ResolveInvariant(context.App.Languages));
yield return(FieldConverters.ResolveLanguages(context.App.Languages));
if (!context.IsFrontendClient)
{
if (context.ShouldResolveLanguages())
{
yield return(FieldConverters.ResolveFallbackLanguages(context.App.Languages));
}
var languages = context.Languages();
if (languages.Any())
{
yield return(FieldConverters.FilterLanguages(context.App.Languages, languages));
}
var assetUrls = context.AssetUrls().ToList();
if (assetUrls.Count > 0)
{
var appId = context.App.NamedId();
var resolveAssetUrls = ValueConverters.ResolveAssetUrls(appId, assetUrls, urlGenerator);
yield return(FieldConverters.ForValues(resolveAssetUrls));
yield return(FieldConverters.ForValues(ValueConverters.ForNested(resolveAssetUrls)));
}
}
}
public ConvertData(IUrlGenerator urlGenerator, IJsonSerializer jsonSerializer,
IAssetRepository assetRepository, IContentRepository contentRepository)
{
this.urlGenerator = urlGenerator;
this.assetRepository = assetRepository;
this.contentRepository = contentRepository;
excludedChangedField = FieldConverters.ExcludeChangedTypes(jsonSerializer);
excludedChangedValue = FieldConverters.ForValues(ValueConverters.ExcludeChangedTypes(jsonSerializer));
excludedHiddenField = FieldConverters.ExcludeHidden;
excludedHiddenValue = FieldConverters.ForValues(ValueConverters.ExcludeHidden);
}
public void Should_filter_for_value_conversion()
{
var field = Fields.String(1, "string", Partitioning.Invariant);
var input =
new ContentFieldData()
.AddJsonValue(JsonValue.Object());
var actual = FieldConverters.ForValues((f, i) => Value.Unset)(input, field);
var expected = new ContentFieldData();
Assert.Equal(expected, actual);
}
public void Should_convert_for_value_conversion()
{
var input =
new ContentFieldData()
.AddValue("iv", JsonValue.Object());
var actual = FieldConverters.ForValues(ValueConverters.EncodeJson(TestUtils.DefaultSerializer))(input, jsonField);
var expected =
new ContentFieldData()
.AddValue("iv", "e30=");
Assert.Equal(expected, actual);
}
public void Should_convert_data_with_value_converter()
{
var field = Fields.String(1, "string", Partitioning.Invariant);
var source =
new ContentFieldData()
.AddInvariant(JsonValue.Object());
var result = FieldConverters.ForValues((value, field, parent) => null)(source, field);
var expected = new ContentFieldData();
Assert.Equal(expected, result);
}
public void Should_cleanup_deleted_ids()
{
var id1 = Guid.NewGuid();
var id2 = Guid.NewGuid();
var input =
new IdContentData()
.AddField(5,
new ContentFieldData()
.AddValue("iv", JsonValue.Array(id1.ToString(), id2.ToString())));
var converter = FieldConverters.ForValues(ValueReferencesConverter.CleanReferences(new[] { id2 }));
var actual = input.ConvertId2Id(schema, converter);
var cleanedValue = (JsonArray)actual[5] !["iv"];
public DataConverter(IJsonSerializer serializer)
{
var decoder = ValueConverters.DecodeJson(serializer);
decodeJsonConverters = new[]
{
FieldConverters.ForValues(decoder, ValueConverters.ForNested(decoder))
};
var encoder = ValueConverters.EncodeJson(serializer);
encodeJsonConverters = new[]
{
FieldConverters.ForValues(encoder, ValueConverters.ForNested(encoder))
};
}
public void Should_convert_for_value_conversion()
{
var field = Fields.Json(1, "json", Partitioning.Invariant);
var source =
new ContentFieldData()
.AddJsonValue(JsonValue.Object());
var result = FieldConverters.ForValues(ValueConverters.EncodeJson(TestUtils.DefaultSerializer))(source, field);
var expected =
new ContentFieldData()
.AddValue("iv", "e30=");
Assert.Equal(expected, result);
}
public void Should_cleanup_deleted_ids()
{
var id1 = DomainId.NewGuid();
var id2 = DomainId.NewGuid();
var source =
new NamedContentData()
.AddField("references",
new ContentFieldData()
.AddJsonValue(JsonValue.Array(id1, id2)))
.AddField("assets",
new ContentFieldData()
.AddJsonValue(JsonValue.Array(id1)))
.AddField("array",
new ContentFieldData()
.AddJsonValue(
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id1, id2)))));
var expected =
new NamedContentData()
.AddField("references",
new ContentFieldData()
.AddJsonValue(JsonValue.Array(id2)))
.AddField("assets",
new ContentFieldData()
.AddJsonValue(JsonValue.Array()))
.AddField("array",
new ContentFieldData()
.AddJsonValue(
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id2)))));
var cleaner = ValueReferencesConverter.CleanReferences(new HashSet <DomainId> {
id2
});
var cleanNested = ValueConverters.ForNested(cleaner);
var converter = FieldConverters.ForValues(cleaner, cleanNested);
var actual = source.ConvertName2Name(schema, converter);
Assert.Equal(expected, actual);
}
private IEnumerable <FieldConverter> GenerateConverters(Context context, ValueConverter?cleanReferences)
{
if (!context.IsFrontendClient)
{
yield return(FieldConverters.ExcludeHidden());
yield return(FieldConverters.ForNestedName2Name(ValueConverters.ExcludeHidden()));
}
yield return(FieldConverters.ExcludeChangedTypes());
yield return(FieldConverters.ForNestedName2Name(ValueConverters.ExcludeChangedTypes()));
if (cleanReferences != null)
{
yield return(FieldConverters.ForValues(cleanReferences));
yield return(FieldConverters.ForNestedName2Name(cleanReferences));
}
yield return(FieldConverters.ResolveInvariant(context.App.LanguagesConfig));
yield return(FieldConverters.ResolveLanguages(context.App.LanguagesConfig));
if (!context.IsFrontendClient)
{
if (context.ShouldResolveLanguages())
{
yield return(FieldConverters.ResolveFallbackLanguages(context.App.LanguagesConfig));
}
var languages = context.Languages();
if (languages.Any())
{
yield return(FieldConverters.FilterLanguages(context.App.LanguagesConfig, languages));
}
var assetUrls = context.AssetUrls();
if (assetUrls.Any())
{
yield return(FieldConverters.ResolveAssetUrls(assetUrls.ToList(), assetUrlGenerator));
}
}
}
public DataConverter(IJsonSerializer serializer)
{
decodeJsonConverters = new[]
{
FieldConverters.ForValues(
ValueConverters.DecodeJson(serializer)),
FieldConverters.ForNestedId2Name(
ValueConverters.DecodeJson(serializer))
};
encodeJsonConverters = new[]
{
FieldConverters.ForValues(
ValueConverters.EncodeJson(serializer)),
FieldConverters.ForNestedName2Id(
ValueConverters.EncodeJson(serializer))
};
}
public ConvertData(IUrlGenerator urlGenerator, IJsonSerializer jsonSerializer,
IAssetRepository assetRepository, IContentRepository contentRepository)
{
Guard.NotNull(urlGenerator, nameof(urlGenerator));
Guard.NotNull(jsonSerializer, nameof(jsonSerializer));
Guard.NotNull(assetRepository, nameof(assetRepository));
Guard.NotNull(contentRepository, nameof(contentRepository));
this.urlGenerator = urlGenerator;
this.assetRepository = assetRepository;
this.contentRepository = contentRepository;
excludedChangedField = FieldConverters.ExcludeChangedTypes(jsonSerializer);
excludedChangedValue = FieldConverters.ForValues(ValueConverters.ForNested(ValueConverters.ExcludeChangedTypes(jsonSerializer)));
excludedHiddenField = FieldConverters.ExcludeHidden;
excludedHiddenValue = FieldConverters.ForValues(ValueConverters.ForNested(ValueConverters.ExcludeHidden));
}
public void Should_convert_name_to_id()
{
var input =
new NamedContentData()
.AddField("field1",
new ContentFieldData()
.AddValue("en", "EN"))
.AddField("field2",
new ContentFieldData()
.AddValue("iv", 1))
.AddField("array",
new ContentFieldData()
.AddValue("iv",
JsonValue.Array(
JsonValue.Object()
.Add("nested1", 100)
.Add("nested2", 200)
.Add("invalid", 300))))
.AddField("invalid",
new ContentFieldData()
.AddValue("iv", 2));
var hideRoot = FieldConverters.ExcludeHidden;
var hideNested = FieldConverters.ForValues(ValueConverters.ForNested(ValueConverters.ExcludeHidden));
var actual = input.ConvertName2IdCloned(schema, hideRoot, hideNested);
var expected =
new IdContentData()
.AddField(1,
new ContentFieldData()
.AddValue("en", "EN"))
.AddField(7,
new ContentFieldData()
.AddValue("iv",
JsonValue.Array(
JsonValue.Object()
.Add("72", 200))));
Assert.Equal(expected, actual);
}
public void Should_cleanup_deleted_ids()
{
var id1 = DomainId.NewGuid();
var id2 = DomainId.NewGuid();
var source =
new ContentData()
.AddField("references",
new ContentFieldData()
.AddInvariant(JsonValue.Array(id1, id2)))
.AddField("assets1",
new ContentFieldData()
.AddInvariant(JsonValue.Array(id1)))
.AddField("array",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id1, id2)))))
.AddField("component",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("references",
JsonValue.Array(id1, id2))
.Add("assets1",
JsonValue.Array(id1))
.Add("array",
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id1, id2))))
.Add(Component.Discriminator, DomainId.Empty)))
.AddField("components",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object()
.Add("references",
JsonValue.Array(id1, id2))
.Add("assets1",
JsonValue.Array(id1))
.Add("array",
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id1, id2))))
.Add(Component.Discriminator, DomainId.Empty))));
var expected =
new ContentData()
.AddField("references",
new ContentFieldData()
.AddInvariant(JsonValue.Array(id2)))
.AddField("assets1",
new ContentFieldData()
.AddInvariant(JsonValue.Array()))
.AddField("array",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id2)))))
.AddField("component",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("references",
JsonValue.Array(id2))
.Add("assets1",
JsonValue.Array())
.Add("array",
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id2))))
.Add(Component.Discriminator, DomainId.Empty)))
.AddField("components",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object()
.Add("references",
JsonValue.Array(id2))
.Add("assets1",
JsonValue.Array())
.Add("array",
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(id2))))
.Add(Component.Discriminator, DomainId.Empty))));
var converter =
FieldConverters.ForValues(
ValueReferencesConverter.CleanReferences(new HashSet <DomainId> {
id2
}));
var actual = source.Convert(schema, converter);
Assert.Equal(expected, actual);
}
public void Should_apply_value_conversion_on_all_levels()
{
var source =
new ContentData()
.AddField("references",
new ContentFieldData()
.AddInvariant(JsonValue.Array(1, 2)))
.AddField("assets1",
new ContentFieldData()
.AddInvariant(JsonValue.Array(1)))
.AddField("array",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(1, 2)))))
.AddField("component",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("references",
JsonValue.Array(1, 2))
.Add("assets1",
JsonValue.Array(1))
.Add("array",
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(1, 2))))
.Add(Component.Discriminator, DomainId.Empty)))
.AddField("components",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object()
.Add("references",
JsonValue.Array(1, 2))
.Add("assets1",
JsonValue.Array(1))
.Add("array",
JsonValue.Array(
JsonValue.Object()
.Add("nested", JsonValue.Array(1, 2))))
.Add(Component.Discriminator, DomainId.Empty))));
var expected =
new ContentData()
.AddField("references",
new ContentFieldData())
.AddField("assets1",
new ContentFieldData()
.AddInvariant(JsonValue.Array(1)))
.AddField("array",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object())))
.AddField("component",
new ContentFieldData()
.AddInvariant(
JsonValue.Object()
.Add("assets1",
JsonValue.Array(1))
.Add("array",
JsonValue.Array(
JsonValue.Object()))
.Add(Component.Discriminator, DomainId.Empty)))
.AddField("components",
new ContentFieldData()
.AddInvariant(
JsonValue.Array(
JsonValue.Object()
.Add("assets1",
JsonValue.Array(1))
.Add("array",
JsonValue.Array(
JsonValue.Object()))
.Add(Component.Discriminator, DomainId.Empty))));
var actual =
source.Convert(schema,
FieldConverters.ForValues((data, field, parent) => field.Name != "assets1" ? null : data));
Assert.Equal(expected, actual);
}
