/// <summary>
/// Builds a strongly typed Entity Model based on a given DXA R2 Data Model.
/// </summary>
/// <param name="entityModel">The strongly typed Entity Model to build. Is <c>null</c> for the first Entity Model Builder in the pipeline.</param>
/// <param name="entityModelData">The DXA R2 Data Model.</param>
/// <param name="baseModelType">The base type for the Entity Model to build.</param>
/// <param name="localization">The context <see cref="ILocalization"/>.</param>
public void BuildEntityModel(ref EntityModel entityModel, EntityModelData entityModelData, Type baseModelType, Localization localization)
{
using (new Tracer(entityModel, entityModelData, baseModelType, localization))
{
if (entityModel == null)
{
throw new DxaException($"The {GetType().Name} must be configured after the DefaultModelBuilder.");
}
GenericTopic genericTopic = entityModel as GenericTopic;
if (genericTopic != null)
{
Log.Debug("Generic Topic encountered...");
EntityModel stronglyTypedTopic = TryConvertToStronglyTypedTopic(genericTopic);
if (stronglyTypedTopic != null)
{
Log.Debug($"Converted {genericTopic} to {stronglyTypedTopic}");
entityModel = stronglyTypedTopic;
}
else
{
Log.Debug($"Unable to convert {genericTopic} to Strongly Typed Topic.");
}
}
}
}
/// <summary>
/// Builds a strongly typed Entity Model based on a given DXA R2 Data Model.
/// </summary>
/// <param name="entityModel">The strongly typed Entity Model to build. Is <c>null</c> for the first Entity Model Builder in the pipeline.</param>
/// <param name="entityModelData">The DXA R2 Data Model.</param>
/// <param name="baseModelType">The base type for the Entity Model to build.</param>
/// <param name="localization">The context <see cref="ILocalization"/>.</param>
public virtual void BuildEntityModel(ref EntityModel entityModel, EntityModelData entityModelData, Type baseModelType, ILocalization localization)
{
using (new Tracer(entityModel, entityModelData, baseModelType, localization))
{
MvcData mvcData = CreateMvcData(entityModelData.MvcData, "Entity");
SemanticSchema semanticSchema = SemanticMapping.GetSchema(entityModelData.SchemaId, localization);
Type modelType = (baseModelType == null) ?
ModelTypeRegistry.GetViewModelType(mvcData) :
semanticSchema.GetModelTypeFromSemanticMapping(baseModelType);
MappingData mappingData = new MappingData
{
SourceViewModel = entityModelData,
ModelType = modelType,
PropertyValidation = new Validation
{
MainSchema = semanticSchema,
InheritedSchemas = GetInheritedSemanticSchemas(entityModelData, localization)
},
Fields = entityModelData.Content,
MetadataFields = entityModelData.Metadata,
Localization = localization
};
entityModel = (EntityModel)CreateViewModel(mappingData);
entityModel.Id = entityModelData.Id;
entityModel.MvcData = mvcData ?? entityModel.GetDefaultView(localization);
}
}
protected virtual object MapComponentLink(EntityModelData entityModelData, Type targetType, Localization localization)
{
if (targetType == typeof(Link))
{
return(new Link
{
Id = entityModelData.Id,
Url = GetLinkUrl(entityModelData, localization)
});
}
if (targetType == typeof(string))
{
return(GetLinkUrl(entityModelData, localization));
}
if (!typeof(EntityModel).IsAssignableFrom(targetType))
{
throw new DxaException($"Cannot map Component Link to property of type '{targetType.Name}'.");
}
if (string.IsNullOrWhiteSpace(entityModelData.SchemaId))
{
return(null);
}
return(ModelBuilderPipeline.CreateEntityModel(entityModelData, targetType, localization));
}
public void CreatePageModel_ComponentLinkExpansion_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.ComponentLinkTestPageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData testEntity = mainRegion.Entities[0];
Assert.IsNotNull(testEntity, "testEntity");
Assert.IsNotNull(testEntity.Content, "testEntity.Content");
EntityModelData[] compLinkField = (EntityModelData[])testEntity.Content["compLink"];
Assert.AreEqual(4, compLinkField.Length, "compLinkField.Length");
EntityModelData notExpandedCompLink = compLinkField[0]; // Has Data Presentation
Assert.IsNotNull(notExpandedCompLink, "notExpandedCompLink");
Assert.AreEqual("9712-10247", notExpandedCompLink.Id, "notExpandedCompLink.Id");
Assert.IsNull(notExpandedCompLink.SchemaId, "notExpandedCompLink.SchemaId");
Assert.IsNull(notExpandedCompLink.Content, "notExpandedCompLink.Content");
EntityModelData expandedCompLink = compLinkField[1]; // Has no Data Presentation
Assert.IsNotNull(expandedCompLink, "expandedCompLink");
Assert.AreEqual("9710", expandedCompLink.Id, "expandedCompLink.Id");
Assert.AreEqual("9709", expandedCompLink.SchemaId, "9710");
Assert.IsNotNull(expandedCompLink.Content, "expandedCompLink.Content");
}
public void CreatePageModel_HybridRegion_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.R2PageIncludesPageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
AssertExpectedIncludePageRegions(pageModel.Regions, new [] { "Header" }, allowEntities: true);
// Header (Include Page) Region should also contain an Entity Model for the Test CP.
RegionModelData header = pageModel.Regions.First(r => r.Name == "Header");
Assert.IsNotNull(header.Entities, "header.Entities");
Assert.AreEqual(1, header.Entities.Count, "header.Entities.Count");
EntityModelData testEntity = header.Entities[0];
MvcData mvcData = testEntity.MvcData;
Assert.IsNotNull(mvcData, "mvcData");
Assert.IsNotNull(mvcData.Parameters, "mvcData.Parameters");
Assert.AreEqual(2, mvcData.Parameters.Count, "mvcData.Parameters.Count");
string name;
Assert.IsTrue(mvcData.Parameters.TryGetValue("name", out name), "mvcData.Parameters['name']");
Assert.AreEqual("value", name, "name");
}
public void CreatePageModel_RichTextEmbeddedMediaManagerItems_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.Tsi2306PageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData article = mainRegion.Entities.LastOrDefault(e => e.MvcData.ViewName == "Article");
Assert.IsNotNull(article, "article");
ContentModelData[] articleBody = (ContentModelData[])article.Content["articleBody"];
RichTextData content = (RichTextData)articleBody[0]["content"];
EntityModelData embeddedMediaManagerItem = content.Fragments.OfType <EntityModelData>().FirstOrDefault();
Assert.IsNotNull(embeddedMediaManagerItem, "embeddedMediaManagerItem");
OutputJson(embeddedMediaManagerItem);
BinaryContentData binaryContent = embeddedMediaManagerItem.BinaryContent;
ExternalContentData externalContent = embeddedMediaManagerItem.ExternalContent;
Assert.IsNotNull(binaryContent, "binaryContent");
Assert.IsNotNull(externalContent, "externalContent");
Assert.AreEqual("https://mmecl.dist.sdlmedia.com/distributions/?o=3e5f81f2-c7b3-47f7-8ede-b84b447195b9", binaryContent.Url, "binaryContent.Url");
Assert.AreEqual("1065-mm-204-dist-file.ecl", binaryContent.FileName, "binaryContent.FileName");
Assert.AreEqual("application/externalcontentlibrary", binaryContent.MimeType, "binaryContent.MimeType");
Assert.AreEqual("ecl:1065-mm-204-dist-file", externalContent.Id, "ecl:1065-mm-204-dist-file");
Assert.AreEqual("html5dist", externalContent.DisplayTypeId, "externalContent.DisplayTypeId");
Assert.IsNotNull(externalContent.Metadata, "externalContent.Metadata");
}
/// <summary>
/// Builds an Entity Data Model from a given CM Component Presentation on a Page.
/// </summary>
/// <param name="entityModelData">The Entity Data Model to build. Is <c>null</c> for the first Model Builder in the pipeline.</param>
/// <param name="cp">The CM Component Presentation (obtained from a Page).</param>
public void BuildEntityModel(ref EntityModelData entityModelData, ComponentPresentation cp)
{
// Add extension data for Context Expressions (if applicable)
ContentModelData contextExpressions = new ContentModelData();
object includeContextExpressions =
GetContextExpressions(
ContextExpressionUtils.GetContextExpressions(
cp.Conditions.Where(c => !c.Negate).Select(c => c.TargetGroup)));
object excludeContextExpressions =
GetContextExpressions(
ContextExpressionUtils.GetContextExpressions(
cp.Conditions.Where(c => c.Negate).Select(c => c.TargetGroup)));
if (includeContextExpressions != null)
{
Logger.Debug("Adding Context Expression Conditions (Include): " +
string.Join(", ", includeContextExpressions));
contextExpressions.Add("Include", includeContextExpressions);
}
if (excludeContextExpressions != null)
{
Logger.Debug("Adding Context Expression Conditions (Exclude): " +
string.Join(", ", excludeContextExpressions));
contextExpressions.Add("Exclude", excludeContextExpressions);
}
if (contextExpressions.Count > 0)
{
entityModelData.SetExtensionData("ContextExpressions", contextExpressions);
}
}
/// <summary>
/// Builds an Entity Data Model from a given CM Component and Component Template.
/// </summary>
/// <param name="entityModelData">The Entity Data Model to build. Is <c>null</c> for the first Model Builder in the pipeline.</param>
/// <param name="component">The CM Component.</param>
/// <param name="ct">The CM Component Template. Can be <c>null</c>.</param>
/// <param name="expandLinkDepth">The level of Component/Keyword links to expand.</param>
/// <remarks>
/// This method is called for Component Presentations on a Page, standalone DCPs and linked Components which are expanded.
/// The <paramref name="expandLinkDepth"/> parameter starts at <see cref="DataModelBuilderSettings.ExpandLinkDepth"/>,
/// but is decremented for expanded Component links (recursively).
/// This Model Builder is designed to be the first in the pipeline and hence ignores the <paramref name="entityModelData"/> input value.
/// </remarks>
public void BuildEntityModel(ref EntityModelData entityModelData, Component component, ComponentTemplate ct, int expandLinkDepth)
{
Logger.Debug($"BuildEntityModel({component}, {ct}, {expandLinkDepth})");
if (component == null)
{
entityModelData = null;
return;
}
// We need Keyword XLinks for Keyword field expansion
component.Load(LoadFlags.KeywordXlinks);
entityModelData = new EntityModelData
{
Id = GetDxaIdentifier(component),
SchemaId = GetDxaIdentifier(component.Schema),
Content = BuildContentModel(component.Content, expandLinkDepth),
Metadata = BuildContentModel(component.Metadata, expandLinkDepth),
BinaryContent = BuildBinaryContentData(component)
};
if (ct == null)
{
return;
}
entityModelData.MvcData = GetEntityMvcData(ct);
entityModelData.HtmlClasses = GetHtmlClasses(ct);
entityModelData.XpmMetadata = GetXpmMetadata(component, ct);
if (ct.IsRepositoryPublishable)
{
entityModelData.Id += "-" + GetDxaIdentifier(ct);
}
}
private EntityModelData GetEntityModelData(ComponentPresentation cp)
{
ComponentTemplate ct = cp.ComponentTemplate;
// Create a Child Rendered Item for the CP in order to make Component linking work.
RenderedItem childRenderedItem = new RenderedItem(new ResolvedItem(cp.Component, ct),
Pipeline.RenderedItem.RenderInstruction);
Pipeline.RenderedItem.AddRenderedItem(childRenderedItem);
EntityModelData entityModel;
if (ct.IsRepositoryPublishable)
{
Logger.Debug($"Not expanding DCP ({cp.Component}, {ct})");
entityModel = new EntityModelData
{
Id = $"{GetDxaIdentifier(cp.Component)}-{GetDxaIdentifier(ct)}"
};
}
else
{
entityModel = Pipeline.CreateEntityModel(cp);
}
return(entityModel);
}
public void BuildEntityModel(ref EntityModelData entityModelData, Component component, ComponentTemplate ct,
bool includeComponentTemplateDetails, int expandLinkDepth)
{
Logger.Debug("Adding folder metadata to entity model metadata.");
Folder folder = (Folder)component.OrganizationalItem;
List <string> schemaIdList = new List <string>();
// Checking for Schema Metadata is very important because we need to stop adding metadata as soon as we found folder without it
while (folder != null && folder.MetadataSchema != null)
{
if (folder.Metadata != null)
{
schemaIdList.Insert(0, new TcmUri(folder.MetadataSchema.Id).ItemId.ToString());
ContentModelData metaData = BuildContentModel(folder.Metadata, expandLinkDepth);
string[] duplicateFieldNames;
ContentModelData emdMetadata = entityModelData.Metadata ?? new ContentModelData();
entityModelData.Metadata = MergeFields(emdMetadata, metaData, out duplicateFieldNames);
}
folder = (Folder)folder.OrganizationalItem;
}
ViewModelData vm = entityModelData as ViewModelData;
if (schemaIdList.Count > 0)
{
CreateSchemaIdListExtensionData(ref vm, schemaIdList);
}
}
public void CreatePageModel_MediaManager_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.MediaManagerPageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData mmItem = mainRegion.Entities[0];
BinaryContentData binaryContent = mmItem.BinaryContent;
ExternalContentData externalContent = mmItem.ExternalContent;
Assert.IsNotNull(binaryContent, "binaryContent");
Assert.AreEqual("https://mmecl.dist.sdlmedia.com/distributions/?o=51498399-31e9-4c89-98eb-0c4256c96f71", binaryContent.Url, "binaryContent.Url");
Assert.AreEqual("application/externalcontentlibrary", binaryContent.MimeType, "binaryContent.MimeType");
Assert.IsNotNull(externalContent, "externalContent");
Assert.AreEqual("ecl:1065-mm-415-dist-file", externalContent.Id, "externalContent.Id");
Assert.AreEqual("html5dist", externalContent.DisplayTypeId, "externalContent.DisplayTypeId");
Assert.IsNotNull(externalContent.Metadata, "externalContent.Metadata");
object globalId;
Assert.IsTrue(externalContent.Metadata.TryGetValue("GlobalId", out globalId), "externalContent.Metadata['GlobalId']");
Assert.AreEqual("51498399-31e9-4c89-98eb-0c4256c96f71", globalId, "globalId");
StringAssert.Contains(externalContent.TemplateFragment, (string)globalId, "externalContent.TemplateFragment");
}
protected virtual ViewModel CreateViewModel(MappingData mappingData)
{
ViewModelData viewModelData = mappingData.SourceViewModel;
EntityModelData entityModelData = viewModelData as EntityModelData;
ViewModel result;
if (string.IsNullOrEmpty(mappingData.ModelId))
{
// Use parameterless constructor
result = (ViewModel)mappingData.ModelType.CreateInstance();
}
else
{
// Pass model Identifier in constructor.
result = (ViewModel)mappingData.ModelType.CreateInstance(mappingData.ModelId);
}
result.ExtensionData = viewModelData.ExtensionData;
result.HtmlClasses = viewModelData.HtmlClasses;
result.XpmMetadata = mappingData.Localization.IsXpmEnabled ? viewModelData.XpmMetadata : null;
MediaItem mediaItem = result as MediaItem;
if (mediaItem != null)
{
BinaryContentData binaryContent = entityModelData?.BinaryContent;
if (binaryContent == null)
{
throw new DxaException(
$"Unable to create Media Item ('{mappingData.ModelType.Name}') because the Data Model '{entityModelData?.Id}' does not contain Binary Content Data."
);
}
mediaItem.Url = binaryContent.Url;
mediaItem.FileName = binaryContent.FileName;
mediaItem.MimeType = binaryContent.MimeType;
mediaItem.FileSize = binaryContent.FileSize;
}
EclItem eclItem = result as EclItem;
if (eclItem != null)
{
ExternalContentData externalContent = entityModelData.ExternalContent;
if (externalContent == null)
{
throw new DxaException(
$"Unable to create ECL Item ('{mappingData.ModelType.Name}') because the Data Model '{entityModelData.Id}' does not contain External Content Data."
);
}
eclItem.EclDisplayTypeId = externalContent.DisplayTypeId;
eclItem.EclTemplateFragment = externalContent.TemplateFragment;
eclItem.EclExternalMetadata = externalContent.Metadata;
eclItem.EclUri = externalContent.Id;
}
MapSemanticProperties(result, mappingData);
return(result);
}
public void EntityModelData_SerializeDeserialize_Success()
{
EntityModelData testEntityModel = CreateTestEntityModel("EntityModelData_SerializeDeserialize_Success");
EntityModelData deserializedEntityModel = JsonSerializeDeserialize(testEntityModel);
AssertEqualEntityModels(testEntityModel, deserializedEntityModel, "deserializedEntityModel");
}
private static void AssertNotExpanded(EntityModelData entityModelData, string subject)
{
Assert.IsNotNull(entityModelData, subject);
Assert.IsNotNull(entityModelData.Id, subject + ".Id");
StringAssert.Matches(entityModelData.Id, new Regex(@"\d+-\d+"), subject + ".Id");
Assert.IsNull(entityModelData.SchemaId, subject + ".SchemaId");
Assert.IsNull(entityModelData.Content, subject + ".Content");
Assert.IsNull(entityModelData.Metadata, subject + ".Metadata");
}
private void AssertEqualEntityModels(EntityModelData expected, EntityModelData actual, string subject)
{
AssertEqualViewModels(expected, actual, subject);
Assert.AreEqual(expected.Id, actual.Id, subject + ".Id");
// TODO: AssertEqualDictionaries(expected.Content, actual.Content, subject + ".Content");
AssertEqualBinaryContent(expected.BinaryContent, actual.BinaryContent, subject + ".BinaryContent");
AssertEqualExternalContent(expected.ExternalContent, actual.ExternalContent, subject + ".ExternalContent");
Assert.AreEqual(expected.LinkUrl, actual.LinkUrl, subject + ".LinkUrl");
}
public void BuildEntityModel(ref EntityModel entityModel, EntityModelData entityModelData, Type baseModelType,
Localization localization)
{
var ugcMetadata = UgcMetadata(entityModelData.ComponentTemplate?.Metadata);
entityModel.SetExtensionData(ShowCommentsExtData, ShowComments(ugcMetadata));
entityModel.SetExtensionData(PostCommentsExtData, PostComments(ugcMetadata) ? UgcPostFormMetadata(ugcMetadata) : null);
entityModel.SetExtensionData(CommentsEntityRegionExt, GetCommentsRegion(ugcMetadata));
}
public void CreatePageModel_Article_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.ArticlePageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
// First assert the Page Model itself looks OK
Assert.IsNotNull(pageModel.MvcData, "pageModel.MvcData");
Assert.IsNull(pageModel.HtmlClasses, "pageModel.HtmlClasses");
Assert.IsNotNull(pageModel.XpmMetadata, "pageModel.XpmMetadata");
Assert.IsNull(pageModel.ExtensionData, "pageModel.ExtensionData");
Assert.IsNull(pageModel.SchemaId, "pageModel.SchemaId");
Assert.IsNull(pageModel.Metadata, "pageModel.Metadata");
Assert.AreEqual("9786", pageModel.Id, "pageModel.Id");
Assert.AreEqual("Test Article used for Automated Testing (Sdl.Web.Tridion.Tests)", pageModel.Title, "pageModel.Title");
Assert.AreEqual("/autotest-parent/test_article_page", pageModel.UrlPath, "pageModel.UrlPath");
Assert.IsNotNull(pageModel.Meta, "pageModel.Meta");
Assert.AreEqual(5, pageModel.Meta.Count, "pageModel.Meta.Count");
Assert.IsNotNull(pageModel.Regions, "pageModel.Regions");
Assert.AreEqual(4, pageModel.Regions.Count, "pageModel.Regions.Count");
AssertExpectedIncludePageRegions(pageModel.Regions, new[] { "Header", "Footer", "Content Tools" });
// Assert the output RenderedItem looks OK
Assert.IsNotNull(testRenderedItem, "testRenderedItem");
Assert.AreEqual(2, testRenderedItem.Binaries.Count, "testRenderedItem.Binaries.Count");
Assert.AreEqual(1, testRenderedItem.ChildRenderedItems.Count, "testRenderedItem.ChildRenderedItems.Count");
// Assert the Article EntityModelData looks OK
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData article = mainRegion.Entities[0];
AssertExpanded(article, true, "article");
StringAssert.Matches(article.Id, new Regex(@"\d+"));
ContentModelData articleBody = (ContentModelData)article.Content["articleBody"];
RichTextData content = (RichTextData)articleBody["content"];
Assert.IsNotNull(content, "content");
Assert.IsNotNull(content.Fragments, "content.Fragments");
// Embedded image in Rich Text field should be represented as an embedded EntityModelData
Assert.AreEqual(3, content.Fragments.Count, "content.Fragments.Count");
EntityModelData image = content.Fragments.OfType <EntityModelData>().FirstOrDefault();
Assert.IsNotNull(image, "image");
Assert.IsNotNull(image.BinaryContent, "image.BinaryContent");
Assert.AreEqual("image/jpeg", image.BinaryContent.MimeType, "image.BinaryContent.MimeType");
// Image should have "altText" metadata field obtained from the original XHTML; see TSI-2289.
Assert.IsNotNull(image.Metadata, "image.Metadata");
object altText;
Assert.IsTrue(image.Metadata.TryGetValue("altText", out altText));
Assert.AreEqual("calculator", altText, "altText");
}
private static int CalcHash(EntityModelData entityModelData)
{
int h0 = entityModelData.Id?.GetHashCode() ?? 0;
int h1 = entityModelData.HtmlClasses?.GetHashCode() ?? 0;
int h2 = (int)entityModelData.SerializationHashCode;
int h3 = entityModelData.LinkUrl?.GetHashCode() ?? 0;
int h4 = entityModelData.MvcData?.GetHashCode() ?? 0;
return(Hash.CombineHashCodes(h0, h1, h2, h3, h4));
}
public void CreateEntityModel_WithoutComponentTemplate_Success()
{
string[] articleDcpIds = TestFixture.ArticleDcpId.Split('/');
Component article = (Component)TestSession.GetObject(articleDcpIds[0]);
RenderedItem testRenderedItem;
EntityModelData entityModel = CreateEntityModel(article, null, out testRenderedItem);
// TODO TSI-132: further assertions
}
/// <summary>
/// Creates an Entity Data Model from a given CM Component Presentation on a Page.
/// </summary>
/// <param name="cp">The CM Component Presentation (obtained from a Page).</param>
public EntityModelData CreateEntityModel(ComponentPresentation cp)
{
EntityModelData entityModelData = null;
foreach (IEntityModelDataBuilder entityModelBuilder in _entityModelBuilders)
{
entityModelBuilder.BuildEntityModel(ref entityModelData, cp);
}
return(entityModelData);
}
public void CreateEntityModel_WithCategoryLink_Success()
{
Component testComponent = (Component)TestSession.GetObject(TestFixture.TestComponentWebDavUrl);
RenderedItem testRenderedItem;
EntityModelData testEntity = CreateEntityModel(testComponent, null, out testRenderedItem);
string[] externalLinkField = (string[])testEntity.Content["ExternalLink"];
Assert.AreEqual(2, externalLinkField.Length, "externalLinkField.Length");
Assert.AreEqual("http://www.sdl.com", externalLinkField[0], "externalLinkField[0]");
Assert.AreEqual("tcm:1065-2702-512", externalLinkField[1], "externalLinkField[1]"); // NOTE: This is a (managed) Category link (!)
}
protected virtual string GetLinkUrl(EntityModelData entityModelData, ILocalization localization)
{
if (entityModelData.LinkUrl != null)
{
return(entityModelData.LinkUrl);
}
Log.Debug($"Link URL for Entity Model '{entityModelData.Id}' not resolved by Model Service.");
string componentUri = localization.GetCmUri(entityModelData.Id);
return(SiteConfiguration.LinkResolver.ResolveLink(componentUri));
}
public void CreatePageModel_ArticleDcp_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.ArticleDcpPageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData article = mainRegion.Entities[0];
AssertNotExpanded(article, "article");
}
private static void AssertExpanded(EntityModelData entityModelData, bool hasContent, string subject)
{
Assert.IsNotNull(entityModelData, subject);
Assert.IsNotNull(entityModelData.Id, subject + ".Id");
Assert.IsNotNull(entityModelData.SchemaId, subject + ".SchemaId");
if (hasContent)
{
Assert.IsNotNull(entityModelData.Content, subject + ".Content");
}
else
{
Assert.IsNull(entityModelData.Content, subject + ".Content");
}
}
/// <summary>
/// Builds an Entity Data Model from a given CM Component and Component Template.
/// </summary>
/// <param name="entityModelData">The Entity Data Model to build. Is <c>null</c> for the first Model Builder in the pipeline.</param>
/// <param name="component">The CM Component.</param>
/// <param name="ct">The CM Component Template. Can be <c>null</c>.</param>
/// <param name="expandLinkDepth">The level of Component/Keyword links to expand.</param>
/// <remarks>
/// This method is called for Component Presentations on a Page, standalone DCPs and linked Components which are expanded.
/// The <paramref name="expandLinkDepth"/> parameter starts at <see cref="DataModelBuilderSettings.ExpandLinkDepth"/>,
/// but is decremented for expanded Component links (recursively).
/// </remarks>
public void BuildEntityModel(ref EntityModelData entityModelData, Component component, ComponentTemplate ct, int expandLinkDepth)
{
if (!IsEclItem(component))
{
return;
}
Logger.Debug($"Processing ECL Stub Component {component.FormatIdentifier()}");
using (ExternalContentLibrary externalContentLibrary = new ExternalContentLibrary(Pipeline))
{
XmlElement externalMetadata = externalContentLibrary.BuildEntityModel(entityModelData, component);
entityModelData.ExternalContent.Metadata = BuildContentModel(externalMetadata, expandLinkDepth: 0);
}
}
/// <summary>
/// Creates an Entity Data Model from a given CM Component and Component Template.
/// </summary>
/// <param name="component">The CM Component.</param>
/// <param name="ct">The CM Component Template. Can be <c>null</c>.</param>
/// <param name="expandLinkDepth">The level of Component/Keyword links to expand. If not specified or <c>null</c>, <see cref="DataModelBuilderSettings.ExpandLinkDepth"/> is used.</param>
/// <remarks>
/// This method is called for Component Presentations on a Page, standalone DCPs and linked Components which are expanded.
/// </remarks>
public EntityModelData CreateEntityModel(Component component, ComponentTemplate ct, int?expandLinkDepth = null)
{
if (!expandLinkDepth.HasValue)
{
expandLinkDepth = Settings.ExpandLinkDepth;
}
EntityModelData entityModelData = null;
foreach (IEntityModelDataBuilder entityModelBuilder in _entityModelBuilders)
{
entityModelBuilder.BuildEntityModel(ref entityModelData, component, ct, expandLinkDepth.Value);
}
return(entityModelData);
}
internal static EntityModel CreateEntityModelInternal(EntityModelData entityModelData, Type baseModelType,
ILocalization localization)
{
EntityModel entityModel = null;
foreach (IEntityModelBuilder entityModelBuilder in _entityModelBuilders)
{
entityModelBuilder.BuildEntityModel(ref entityModel, entityModelData, baseModelType, localization);
}
if (entityModel == null)
{
throw new DxaException("Entity Model is null after all Entity Model Builders have been run.");
}
return(entityModel);
}
public void CreatePageModel_KeywordModelExpansion_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.Tsi2316PageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData testEntity = mainRegion.Entities[0];
KeywordModelData notPublishedKeyword = (KeywordModelData)testEntity.Content["notPublishedKeyword"];
KeywordModelData publishedKeyword = (KeywordModelData)testEntity.Content["publishedKeyword"];
AssertExpanded(notPublishedKeyword, false, "notPublishedKeyword");
AssertNotExpanded(publishedKeyword, true, "publishedKeyword");
}
private void AddComponentPresentationRegions(IDictionary <string, RegionModelData> regionModels, Page page)
{
foreach (ComponentPresentation cp in page.ComponentPresentations)
{
ComponentTemplate ct = cp.ComponentTemplate;
// Create a Child Rendered Item for the CP in order to make Component linking work.
RenderedItem childRenderedItem = new RenderedItem(new ResolvedItem(cp.Component, ct), Pipeline.RenderedItem.RenderInstruction);
Pipeline.RenderedItem.AddRenderedItem(childRenderedItem);
EntityModelData entityModel;
if (ct.IsRepositoryPublishable)
{
Logger.Debug($"Not expanding DCP ({cp.Component}, {ct})");
entityModel = new EntityModelData
{
Id = $"{GetDxaIdentifier(cp.Component)}-{GetDxaIdentifier(ct)}"
};
}
else
{
entityModel = Pipeline.CreateEntityModel(cp);
}
string regionName;
MvcData regionMvcData = GetRegionMvcData(cp.ComponentTemplate, out regionName);
RegionModelData regionModel;
if (regionModels.TryGetValue(regionName, out regionModel))
{
if (!regionMvcData.Equals(regionModel.MvcData))
{
throw new DxaException($"Conflicting Region MVC data detected: [{regionMvcData}] versus [{regionModel.MvcData}]");
}
}
else
{
regionModel = new RegionModelData
{
Name = regionName,
MvcData = regionMvcData,
Entities = new List <EntityModelData>()
};
regionModels.Add(regionName, regionModel);
}
regionModel.Entities.Add(entityModel);
}
}
public void ContentModelData_SerializeDeserialize_Success()
{
ContentModelData testContentModel = CreateTestContentModel(
"ContentModelData_SerializeDeserialize_Success",
includeEntityModels: true,
includeKeywordModels: true
);
string testTextField = (string)testContentModel["textField"];
string[] testMultiValueTextField = (string[])testContentModel["multiValueTextField"];
RichTextData testRichTextField = (RichTextData)testContentModel["richTextField"];
RichTextData[] testMultiValueRichTextField = (RichTextData[])testContentModel["multiValueRichTextField"];
EntityModelData testCompLinkField = (EntityModelData)testContentModel["compLinkField"];
EntityModelData[] testMultiValueCompLinkField = (EntityModelData[])testContentModel["multiValueCompLinkField"];
KeywordModelData testKeywordField = (KeywordModelData)testContentModel["keywordField"];
KeywordModelData[] testMultiValueKeywordField = (KeywordModelData[])testContentModel["multiValueKeywordField"];
ContentModelData deserializedContentModel = JsonSerializeDeserialize(testContentModel);
RichTextData deserializedRichTextField = deserializedContentModel["richTextField"] as RichTextData;
RichTextData[] deserializedMultiValueRichTextField = deserializedContentModel["multiValueRichTextField"] as RichTextData[];
EntityModelData deserializedCompLink = deserializedContentModel["compLinkField"] as EntityModelData;
EntityModelData[] deserializedMultiValueCompLink = deserializedContentModel["multiValueCompLinkField"] as EntityModelData[];
KeywordModelData deserializedKeyword = deserializedContentModel["keywordField"] as KeywordModelData;
KeywordModelData[] deserializedMultiValueKeywordField = (KeywordModelData[])deserializedContentModel["multiValueKeywordField"];
Assert.IsNotNull(deserializedRichTextField, "deserializedRichTextField");
Assert.IsNotNull(deserializedMultiValueRichTextField, "deserializedMultiValueRichTextField");
Assert.IsNotNull(deserializedCompLink, "deserializedCompLink");
Assert.IsNotNull(deserializedMultiValueCompLink, "deserializedMultiValueCompLink");
Assert.IsNotNull(deserializedKeyword, "deserializedKeyword");
Assert.IsNotNull(deserializedMultiValueKeywordField, "deserializedMultiValueKeywordField");
Assert.AreEqual(testTextField, deserializedContentModel["textField"], "textField");
AssertEqualCollections(testMultiValueTextField, deserializedContentModel["multiValueTextField"] as string[], "multiValueTextField");
Assert.AreEqual(testRichTextField.Fragments.Count, deserializedRichTextField.Fragments.Count, "deserializedRichTextField.Fragments.Count");
AssertEqualCollections(testMultiValueRichTextField, deserializedMultiValueRichTextField, "deserializedMultiValueRichTextField");
Assert.AreEqual(testCompLinkField.Id, deserializedCompLink.Id, "deserializedCompLink.Id");
AssertEqualCollections(testMultiValueCompLinkField, deserializedMultiValueCompLink, "deserializedMultiValueCompLink");
Assert.AreEqual(testKeywordField.Id, deserializedKeyword.Id, "deserializedKeyword.Id");
AssertEqualCollections(testMultiValueKeywordField, deserializedMultiValueKeywordField, "deserializedMultiValueKeywordField");
}
