private void AddComponentPresentationRegions(IDictionary <string, RegionModelData> regionModels, Page page)
{
foreach (ComponentPresentation cp in page.ComponentPresentations)
{
var entityModel = GetEntityModelData(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 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");
}
private static RegionModelData GetMainRegion(PageModelData pageModelData)
{
RegionModelData mainRegion = pageModelData.Regions.FirstOrDefault(r => r.Name == "Main");
Assert.IsNotNull(mainRegion, "No 'Main' Region found in Page Model.");
return(mainRegion);
}
/// <summary>
/// Builds a strongly typed Page Model from a given DXA R2 Data Model.
/// </summary>
/// <param name="pageModel">The strongly typed Page Model to build. Is <c>null</c> for the first Page Model Builder in the pipeline.</param>
/// <param name="pageModelData">The DXA R2 Data Model.</param>
/// <param name="includePageRegions">Indicates whether Include Page Regions should be included.</param>
/// <param name="localization">The context <see cref="Localization"/>.</param>
public void BuildPageModel(ref PageModel pageModel, PageModelData pageModelData, bool includePageRegions, ILocalization localization)
{
using (new Tracer(pageModel, pageModelData, includePageRegions, localization))
{
if ((pageModel == null) || !pageModel.Regions.OfType <SmartTargetRegion>().Any())
{
Log.Debug("No SmartTarget Regions on Page.");
return;
}
// "Upgrade" the PageModel to a SmartTargetPageModel, so we can store AllowDuplicates in the Page Model.
SmartTargetPageModel smartTargetPageModel = new SmartTargetPageModel(pageModel)
{
AllowDuplicates = GetAllowDuplicatesOnSamePage(pageModelData, localization),
NoCache = true // Don't cache the Page Model, because its contents are dynamic.
};
pageModel = smartTargetPageModel;
// Set SmartTargetRegionModel.MaxItem based on the Region Metadata
foreach (SmartTargetRegion smartTargetRegion in pageModel.Regions.OfType <SmartTargetRegion>())
{
string regionName = smartTargetRegion.Name;
RegionModelData regionModelData = pageModelData.Regions.First(r => r.Name == regionName);
int maxItems = 100; // Default
if ((regionModelData.Metadata != null) && regionModelData.Metadata.ContainsKey("maxItems"))
{
maxItems = GetInt(regionModelData.Metadata["maxItems"]);
}
smartTargetRegion.MaxItems = maxItems;
}
PopulateSmartTargetRegions(smartTargetPageModel, localization);
}
}
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");
}
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");
}
public void RegionModelData_SerializeDeserialize_Success()
{
RegionModelData testRegionModel = CreateTestRegionModel("RegionModelData_SerializeDeserialize_Success");
RegionModelData deserializedRegionModel = JsonSerializeDeserialize(testRegionModel);
AssertEqualRegionModels(testRegionModel, deserializedRegionModel, "deserializedRegionModel");
}
private static void AssertEqualRegionModels(RegionModelData expected, RegionModelData actual, string subject)
{
AssertEqualViewModels(expected, actual, subject);
Assert.AreEqual(expected.Name, actual.Name, subject + ".Name");
AssertEqualCollections(expected.Entities, actual.Entities, subject + ".Entities");
AssertEqualCollections(expected.Regions, actual.Regions, subject + ".Regions");
Assert.AreEqual(expected.IncludePageId, actual.IncludePageId, subject + ".IncludePageId");
}
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 List <RegionModelData> GetNativeRegions(IList <IRegion> regions)
{
List <RegionModelData> regionModelDatas = new List <RegionModelData>();
foreach (IRegion region in regions)
{
string moduleName;
string regionName = region.RegionName;
string viewName = region.RegionSchema != null
? GetViewNameFromSchemaTitle(region.RegionSchema.Title)
: regionName;
viewName = StripModuleName(viewName, out moduleName);
ContentModelData metadata = BuildContentModel(region.Metadata, expandLinkDepth: 0);
string schemaId = GetDxaIdentifier(region.RegionSchema);
var regionModelData = new RegionModelData
{
Name = regionName,
SchemaId = schemaId,
MvcData = new MvcData
{
ViewName = viewName,
AreaName = moduleName
},
Entities = new List <EntityModelData>(),
Metadata = metadata,
XpmMetadata = GetXpmMetadata(region)
};
foreach (var cp in region.ComponentPresentations)
{
var entityModel = GetEntityModelData(cp);
string dxaRegionName;
GetRegionMvcData(cp.ComponentTemplate, out dxaRegionName, string.Empty);
if (!string.IsNullOrEmpty(dxaRegionName) && dxaRegionName != regionName)
{
Logger.Warning($"Component Template '{cp.ComponentTemplate.Title}' is placed inside Region '{regionName}', but Region name in Component Template Metadata is '{dxaRegionName}'.");
}
regionModelData.Entities.Add(entityModel);
}
IList <IRegion> nestedRegions = region.GetPropertyValue <IList <IRegion> >("Regions");
if (nestedRegions != null)
{
regionModelData.Regions = GetNativeRegions(nestedRegions);
}
regionModelDatas.Add(regionModelData);
}
return(regionModelDatas);
}
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");
}
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 CreatePageModel_RichTextComponentLinks_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.ArticlePageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData article = mainRegion.Entities[0];
ContentModelData articleBody = (ContentModelData)article.Content["articleBody"];
RichTextData content = (RichTextData)articleBody["content"];
string firstHtmlFragment = (string)content.Fragments[0];
StringAssert.Contains(firstHtmlFragment, "href=\"tcm:1065-9710\"");
StringAssert.Contains(firstHtmlFragment, "<!--CompLink tcm:1065-9710-->");
}
public void CreatePageModel_EmbeddedFields_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.Tsi1758PageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData testEntity = mainRegion.Entities[0];
ContentModelData[] topLevelEmbedField1 = (ContentModelData[])testEntity.Content["embedField1"];
ContentModelData nestedEmbedField1 = (ContentModelData)topLevelEmbedField1[0]["embedField1"];
Assert.AreEqual("This is the textField of the first embedField1", topLevelEmbedField1[0]["textField"], "topLevelEmbedField1['textField']");
Assert.AreEqual("This is the link text of embedField1 within the first embedField1", nestedEmbedField1["linkText"], "nestedEmbedField1['linkText']");
}
public void CreatePageModel_ContextExpressions_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.ContextExpressionsPageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData[] entitiesWithExtensionData = mainRegion.Entities.Where(e => e.ExtensionData != null).ToArray();
EntityModelData[] entitiesWithCxInclude = entitiesWithExtensionData.Where(e => e.ExtensionData.ContainsKey("CX.Include")).ToArray();
EntityModelData[] entitiesWithCxExclude = entitiesWithExtensionData.Where(e => e.ExtensionData.ContainsKey("CX.Exclude")).ToArray();
Assert.AreEqual(8, entitiesWithExtensionData.Length, "entitiesWithExtensionData.Length");
Assert.AreEqual(6, entitiesWithCxInclude.Length, "entitiesWithCxInclude.Length");
Assert.AreEqual(4, entitiesWithCxExclude.Length, "entitiesWithCxExclude.Length");
}
protected virtual RegionModel CreateRegionModel(RegionModelData regionModelData, ILocalization localization)
{
MvcData mvcData = CreateMvcData(regionModelData.MvcData, "Region");
Type regionModelType = ModelTypeRegistry.GetViewModelType(mvcData);
RegionModel result = (RegionModel)regionModelType.CreateInstance(regionModelData.Name);
result.ExtensionData = regionModelData.ExtensionData;
result.HtmlClasses = regionModelData.HtmlClasses;
result.MvcData = mvcData;
result.XpmMetadata = localization.IsXpmEnabled ? regionModelData.XpmMetadata : null;
if (regionModelData.Regions != null)
{
IEnumerable <RegionModel> nestedRegionModels = regionModelData.Regions.Select(data => CreateRegionModel(data, localization));
result.Regions.UnionWith(nestedRegionModels);
result.IsVolatile |= result.Regions.Any(region => region.IsVolatile);
}
if (regionModelData.Entities != null)
{
foreach (EntityModelData entityModelData in regionModelData.Entities)
{
EntityModel entityModel;
try
{
entityModel = ModelBuilderPipeline.CreateEntityModel(entityModelData, null, localization);
// indicate to region model that this region is potentially volatile if it contains a volatile entity
result.IsVolatile |= entityModel.IsVolatile;
entityModel.MvcData.RegionName = regionModelData.Name;
}
catch (Exception ex)
{
// If there is a problem mapping an Entity, we replace it with an ExceptionEntity which holds the error details and carry on.
Log.Error(ex);
entityModel = new ExceptionEntity(ex);
}
result.Entities.Add(entityModel);
}
}
return(result);
}
private void AddPredefinedRegions(IDictionary <string, RegionModelData> regionModels, PageTemplate pageTemplate)
{
IEnumerable <XmlElement> regionsMetadata = pageTemplate.Metadata.GetEmbeddedFieldValues("regions");
if (regionsMetadata == null)
{
Logger.Debug($"No predefined Regions found in {pageTemplate.FormatIdentifier()}");
return;
}
foreach (XmlElement regionMetadata in regionsMetadata)
{
string regionName = regionMetadata.GetTextFieldValue("name");
string qualifiedRegionViewName = regionMetadata.GetTextFieldValue("view");
string moduleName;
string regionViewName = StripModuleName(qualifiedRegionViewName, out moduleName);
if (string.IsNullOrEmpty(regionName))
{
regionName = regionViewName;
}
if (regionModels.ContainsKey(regionName))
{
throw new DxaException($"Duplicate predefined Region name '{regionName}' encountered in {pageTemplate.FormatIdentifier()}.");
}
RegionModelData regionModel = new RegionModelData
{
Name = regionName,
MvcData = new MvcData
{
ViewName = regionViewName,
AreaName = moduleName
},
Metadata = ExtractCustomMetadata(regionMetadata, excludeFields: _standardRegionMetadataFields),
Entities = new List <EntityModelData>()
};
regionModels.Add(regionName, regionModel);
}
}
public void CreatePageModel_Article_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.ArticlePageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
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");
RegionModelData[] includePageRegions = pageModel.Regions.Where(r => r.IncludePageId != null).ToArray();
Assert.AreEqual(3, includePageRegions.Length, "includePageRegions.Length");
foreach (RegionModelData includePageRegion in includePageRegions)
{
StringAssert.Matches(includePageRegion.IncludePageId, new Regex(@"\d+"), "includePageRegion.IncludePageId");
}
}
private static RegionModel CreateRegionModel(RegionModelData regionModelData, Localization localization)
{
Common.Models.MvcData mvcData = CreateMvcData(regionModelData.MvcData, "Region");
Type regionModelType = ModelTypeRegistry.GetViewModelType(mvcData);
RegionModel result = (RegionModel)regionModelType.CreateInstance(regionModelData.Name);
result.ExtensionData = regionModelData.ExtensionData;
result.HtmlClasses = regionModelData.HtmlClasses;
result.MvcData = mvcData;
result.XpmMetadata = regionModelData.XpmMetadata;
if (regionModelData.Regions != null)
{
IEnumerable <RegionModel> nestedRegionModels = regionModelData.Regions.Select(data => CreateRegionModel(data, localization));
result.Regions.UnionWith(nestedRegionModels);
}
if (regionModelData.Entities != null)
{
foreach (EntityModelData entityModelData in regionModelData.Entities)
{
EntityModel entityModel;
try
{
entityModel = ModelBuilderPipelineR2.CreateEntityModel(entityModelData, null, localization);
entityModel.MvcData.RegionName = regionModelData.Name;
}
catch (Exception ex)
{
// If there is a problem mapping an Entity, we replace it with an ExceptionEntity which holds the error details and carry on.
Log.Error(ex);
entityModel = new ExceptionEntity(ex);
}
result.Entities.Add(entityModel);
}
}
return(result);
}
public void CreatePageModel_SmartTarget_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.SmartTargetPageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
Assert.IsNotNull(pageModel.Metadata, "pageModel.Metadata");
object allowDups;
Assert.IsTrue(pageModel.Metadata.TryGetValue("allowDuplicationOnSamePage", out allowDups), "pageModel.Metadata[allowDuplicationOnSamePage]");
Assert.AreEqual("Use core configuration", allowDups, "allowDups");
RegionModelData example1Region = pageModel.Regions.FirstOrDefault(r => r.Name == "Example1");
Assert.IsNotNull(example1Region, "example1Region");
Assert.IsNotNull(example1Region.Metadata, "example1Region.Metadata");
object maxItems;
Assert.IsTrue(example1Region.Metadata.TryGetValue("maxItems", out maxItems), "example1Region.Metadata[maxItems]");
Assert.AreEqual("3", maxItems, "maxItems");
}
public void CreatePageModel_HtmlClasses_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.Tsi1614PageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData article = mainRegion.Entities[0];
Assert.AreEqual("article tsi1614", article.HtmlClasses, "article.HtmlClasses");
ContentModelData articleBody = article.Content["articleBody"] as ContentModelData;
Assert.IsNotNull(articleBody, "articleBody");
RichTextData content = articleBody["content"] as RichTextData;
Assert.IsNotNull(content, "content");
EntityModelData embeddedEntity = content.Fragments.OfType <EntityModelData>().FirstOrDefault();
Assert.IsNotNull(embeddedEntity, "embeddedEntity");
Assert.AreEqual("test tsi1614", embeddedEntity.HtmlClasses, "embeddedEntity.HtmlClasses");
}
public void CreatePageModel_Flickr_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.FlickrTestPageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData flickrImage = mainRegion.Entities[0];
BinaryContentData binaryContent = flickrImage.BinaryContent;
ExternalContentData externalContent = flickrImage.ExternalContent;
Assert.IsNotNull(binaryContent, "binaryContent");
StringAssert.Matches(binaryContent.Url, new Regex(@"/Preview/Images/.*\.jpg"), "binaryContent.Url");
Assert.AreEqual("image/jpeg", binaryContent.MimeType, "binaryContent.MimeType");
Assert.IsNotNull(externalContent, "externalContent");
Assert.AreEqual("ecl:1065-flickr-5606989559_6b62b3c3fc_72157626470204584-img-file", externalContent.Id, "externalContent.Id");
Assert.AreEqual("img", externalContent.DisplayTypeId, "externalContent.DisplayTypeId");
Assert.IsNotNull(externalContent.Metadata, "externalContent.Metadata");
object width;
Assert.IsTrue(externalContent.Metadata.TryGetValue("Width", out width), "externalContent.Metadata['Width']");
Assert.AreEqual("1024", width, "width");
}
private void AddIncludePageRegions(IDictionary <string, RegionModelData> regionModels, PageTemplate pageTemplate)
{
IEnumerable <string> includes = pageTemplate.Metadata.GetTextFieldValues("includes"); // TODO: use external link field (?)
if (includes == null)
{
Logger.Debug($"No include Pages found in {pageTemplate.FormatIdentifier()}");
return;
}
foreach (string include in includes)
{
string includePageId;
if (include.StartsWith(LegacyIncludePrefix))
{
// Legacy include: publish path. Try to convert to WebDAV URL.
string relativeUrl = include.Substring(LegacyIncludePrefix.Length).Replace('-', ' ');
Publication contextPub = (Publication)pageTemplate.ContextRepository;
includePageId = $"/webdav/{contextPub.Title}/{contextPub.RootStructureGroup.Title}/_System/include/{relativeUrl}.tpg";
Logger.Debug($"Converted legacy Page include '{include}' to WebDAV URL '{includePageId}'.");
}
else
{
includePageId = include;
}
Page includePage = (Page)Pipeline.Session.GetObject(includePageId);
string moduleName;
string regionViewName = StripModuleName(includePage.Title, out moduleName);
string regionName = regionViewName;
if (regionModels.ContainsKey(regionName))
{
// TODO: log this? Throw exception? Promote Region to Include Page Region?
Logger.Debug("TODO: merge include Page Region '{regionName}'");
continue;
}
RegionModelData includePageRegion = new RegionModelData
{
Name = regionName,
MvcData = new MvcData
{
ViewName = regionViewName,
AreaName = moduleName
},
IncludePageId = GetDxaIdentifier(includePage)
};
if (Pipeline.Settings.GenerateXpmMetadata)
{
includePageRegion.XpmMetadata = new Dictionary <string, object>
{
{ "IncludedFromPageID", GetTcmIdentifier(includePage) },
{ "IncludedFromPageTitle", includePage.Title },
{ "IncludedFromPageFileName", includePage.FileName }
};
}
regionModels.Add(regionName, includePageRegion);
}
}
protected virtual RegionModel CreateRegionModel(RegionModelData regionModelData, ILocalization localization)
{
MvcData mvcData = CreateMvcData(regionModelData.MvcData, "Region");
Type regionModelType = ModelTypeRegistry.GetViewModelType(mvcData);
RegionModel result = (RegionModel)regionModelType.CreateInstance(regionModelData.Name);
result.ExtensionData = regionModelData.ExtensionData;
result.HtmlClasses = regionModelData.HtmlClasses;
result.MvcData = mvcData;
result.XpmMetadata = localization.IsXpmEnabled ? regionModelData.XpmMetadata : null;
result.SchemaId = regionModelData.SchemaId;
if (!string.IsNullOrEmpty(regionModelData.SchemaId))
{
SemanticSchema semanticSchema = SemanticMapping.GetSchema(regionModelData.SchemaId, localization);
Type modelType = ModelTypeRegistry.GetViewModelType(mvcData);
MappingData mappingData = new MappingData
{
SourceViewModel = regionModelData,
ModelType = modelType,
PropertyValidation = new Validation
{
MainSchema = semanticSchema,
InheritedSchemas = GetInheritedSemanticSchemas(regionModelData, localization)
},
Fields = null,
MetadataFields = regionModelData.Metadata,
Localization = localization
};
MapSemanticProperties(result, mappingData);
}
if (regionModelData.Regions != null)
{
IEnumerable <RegionModel> nestedRegionModels = regionModelData.Regions.Select(data => CreateRegionModel(data, localization));
result.Regions.UnionWith(nestedRegionModels);
result.IsVolatile |= result.Regions.Any(region => region.IsVolatile);
}
if (regionModelData.Entities != null)
{
foreach (EntityModelData entityModelData in regionModelData.Entities)
{
EntityModel entityModel;
try
{
entityModel = ModelBuilderPipeline.CreateEntityModel(entityModelData, null, localization);
// indicate to region model that this region is potentially volatile if it contains a volatile entity
result.IsVolatile |= entityModel.IsVolatile;
entityModel.MvcData.RegionName = regionModelData.Name;
}
catch (Exception ex)
{
// If there is a problem mapping an Entity, we replace it with an ExceptionEntity which holds the error details and carry on.
Log.Error(ex);
entityModel = new ExceptionEntity(ex);
}
result.Entities.Add(entityModel);
}
}
return(result);
}
private void AddIncludePageRegions(IDictionary <string, RegionModelData> regionModels, PageTemplate pageTemplate)
{
IEnumerable <string> includes = pageTemplate.Metadata.GetTextFieldValues("includes"); // TODO: use external link field (?)
if (includes == null)
{
Logger.Debug($"No include Pages found in {pageTemplate.FormatIdentifier()}");
return;
}
Publication contextPub = (Publication)pageTemplate.ContextRepository;
foreach (string include in includes)
{
string includePageId;
if (TcmUri.IsValid(include) || include.StartsWith("/webdav/"))
{
// TCM URI or WebDAV URL
includePageId = include;
}
else
{
// Legacy include: publish path. Convert to WebDAV URL.
includePageId = ConvertPublishPathToWebDavUrl(include, contextPub);
}
Page includePage;
try
{
includePage = (Page)Pipeline.Session.GetObject(includePageId);
includePage.Load(LoadFlags.None); // Force load the Page
}
catch (Exception ex)
{
throw new DxaException($"Unable to load include page for '{include}'", ex);
}
string moduleName;
string regionViewName = StripModuleName(includePage.Title, out moduleName);
string regionName = regionViewName;
RegionModelData includePageRegion;
if (regionModels.TryGetValue(regionName, out includePageRegion))
{
Logger.Debug($"Promoting Region '{regionName}' to Include Page Region.");
}
else
{
includePageRegion = new RegionModelData
{
Name = regionName,
MvcData = new MvcData
{
ViewName = regionViewName,
AreaName = moduleName
}
};
regionModels.Add(regionName, includePageRegion);
}
includePageRegion.IncludePageId = GetDxaIdentifier(includePage);
if (Pipeline.Settings.GenerateXpmMetadata)
{
includePageRegion.XpmMetadata = new Dictionary <string, object>
{
{ "IncludedFromPageID", GetTcmIdentifier(includePage) },
{ "IncludedFromPageTitle", includePage.Title },
{ "IncludedFromPageFileName", includePage.FileName }
};
}
}
}
