public ContentEnricherAssetsTests()
{
requestContext = new Context(Mocks.FrontendUser(), Mocks.App(appId, Language.DE));
var schemaDef =
new Schema(schemaId.Name)
.AddAssets(1, "asset1", Partitioning.Invariant, new AssetsFieldProperties
{
ResolveImage = true,
MinItems = 2,
MaxItems = 3
})
.AddAssets(2, "asset2", Partitioning.Language, new AssetsFieldProperties
{
ResolveImage = true,
MinItems = 1,
MaxItems = 1
})
.ConfigureFieldsInLists("asset1", "asset2");
A.CallTo(() => assetUrlGenerator.GenerateUrl(A <string> .Ignored))
.ReturnsLazily(new Func <string, string>(id => $"url/to/{id}"));
void SetupSchema(NamedId <Guid> id, Schema def)
{
var schemaEntity = Mocks.Schema(appId, id, def);
A.CallTo(() => contentQuery.GetSchemaOrThrowAsync(requestContext, id.Id.ToString()))
.Returns(schemaEntity);
}
SetupSchema(schemaId, schemaDef);
sut = new ContentEnricher(assetQuery, assetUrlGenerator, new Lazy <IContentQueryService>(() => contentQuery), contentWorkflow);
}
public static FieldConverter ResolveAssetUrls(IReadOnlyCollection <string>?fields, IAssetUrlGenerator urlGenerator)
{
if (fields?.Any() != true)
{
return((data, field) => data);
}
var isAll = fields.First() == "*";
return((data, field) =>
{
if (field is IField <AssetsFieldProperties> && (isAll || fields.Contains(field.Name)))
{
foreach (var partition in data)
{
if (partition.Value is JsonArray array)
{
for (var i = 0; i < array.Count; i++)
{
var id = array[i].ToString();
array[i] = JsonValue.Create(urlGenerator.GenerateUrl(id));
}
}
}
}
return data;
});
}
private void ResolveAssets(ISchemaEntity schema, IGrouping <Guid, ContentEntity> contents, ILookup <Guid, IEnrichedAssetEntity> assets)
{
foreach (var field in schema.SchemaDef.ResolvingAssets())
{
foreach (var content in contents)
{
if (content.ReferenceData == null)
{
content.ReferenceData = new NamedContentData();
}
var fieldReference = content.ReferenceData.GetOrAdd(field.Name, _ => new ContentFieldData()) !;
if (content.DataDraft.TryGetValue(field.Name, out var fieldData) && fieldData != null)
{
foreach (var partitionValue in fieldData)
{
var referencedImage =
field.GetReferencedIds(partitionValue.Value, Ids.ContentOnly)
.Select(x => assets[x])
.SelectMany(x => x)
.FirstOrDefault(x => x.IsImage);
if (referencedImage != null)
{
var url = assetUrlGenerator.GenerateUrl(referencedImage.Id.ToString());
content.CacheDependencies.Add(referencedImage.Id);
content.CacheDependencies.Add(referencedImage.Version);
fieldReference.AddJsonValue(partitionValue.Key, JsonValue.Create(url));
}
}
}
}
}
}
public ResolveAssetsTests()
{
requestContext = new Context(Mocks.FrontendUser(), Mocks.App(appId, Language.DE));
var schemaDef =
new Schema(schemaId.Name)
.AddAssets(1, "asset1", Partitioning.Invariant, new AssetsFieldProperties
{
ResolveImage = true,
MinItems = 2,
MaxItems = 3
})
.AddAssets(2, "asset2", Partitioning.Language, new AssetsFieldProperties
{
ResolveImage = true,
MinItems = 1,
MaxItems = 1
})
.SetFieldsInLists("asset1", "asset2");
A.CallTo(() => assetUrlGenerator.GenerateUrl(A <string> .Ignored))
.ReturnsLazily(new Func <string, string>(id => $"url/to/{id}"));
schemaProvider = x =>
{
if (x == schemaId.Id)
{
return(Task.FromResult(Mocks.Schema(appId, schemaId, schemaDef)));
}
else
{
throw new DomainObjectNotFoundException(x.ToString(), typeof(ISchemaEntity));
}
};
sut = new ResolveAssets(assetUrlGenerator, assetQuery, requestCache);
}
public static FieldConverter ResolveAssetUrls(IReadOnlyCollection <string>?fields, IAssetUrlGenerator urlGenerator)
{
if (fields?.Any() != true)
{
return((data, field) => data);
}
bool ShouldHandle(IField field, IField?parent = null)
{
if (field is IField <AssetsFieldProperties> )
{
if (fields.Contains("*"))
{
return(true);
}
if (parent == null)
{
return(fields.Contains(field.Name));
}
else
{
return(fields.Contains($"{parent.Name}.{field.Name}"));
}
}
return(false);
}
void Resolve(IJsonValue value)
{
if (value is JsonArray array)
{
for (var i = 0; i < array.Count; i++)
{
var id = array[i].ToString();
array[i] = JsonValue.Create(urlGenerator.GenerateUrl(id));
}
}
}
return((data, field) =>
{
if (ShouldHandle(field))
{
foreach (var partition in data)
{
Resolve(partition.Value);
}
}
else if (field is IArrayField arrayField)
{
foreach (var partition in data)
{
if (partition.Value is JsonArray array)
{
for (var i = 0; i < array.Count; i++)
{
if (array[i] is JsonObject arrayItem)
{
foreach (var(key, value) in arrayItem)
{
if (arrayField.FieldsByName.TryGetValue(key, out var nestedField) && ShouldHandle(nestedField, field))
{
Resolve(value);
}
}
}
}
}
}
}
return data;
});
}
public FieldConvertersTests()
{
A.CallTo(() => assetUrlGenerator.GenerateUrl(A <string> .Ignored))
.ReturnsLazily(ctx => $"url/to/{ctx.GetArgument<string>(0)}");
}
