/// <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);
}
}
/// <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="ILocalization"/>.</param>
public virtual void BuildPageModel(ref PageModel pageModel, PageModelData pageModelData, bool includePageRegions, ILocalization localization)
{
using (new Tracer(pageModel, pageModelData, includePageRegions, localization))
{
MvcData mvcData = CreateMvcData(pageModelData.MvcData, "Page");
Type modelType = ModelTypeRegistry.GetViewModelType(mvcData);
if (modelType == typeof(PageModel))
{
// Standard Page Model.
pageModel = new PageModel(pageModelData.Id)
{
ExtensionData = pageModelData.ExtensionData,
HtmlClasses = pageModelData.HtmlClasses,
XpmMetadata = localization.IsXpmEnabled ? pageModelData.XpmMetadata : null,
};
}
else if (pageModelData.SchemaId == null)
{
// Custom Page Model, but no custom metadata.
pageModel = (PageModel)modelType.CreateInstance(pageModelData.Id);
pageModel.ExtensionData = pageModelData.ExtensionData;
pageModel.HtmlClasses = pageModelData.HtmlClasses;
pageModel.XpmMetadata = localization.IsXpmEnabled ? pageModelData.XpmMetadata : null;
}
else
{
// Custom Page Model with custom metadata; do full-blown model mapping.
MappingData mappingData = new MappingData
{
SourceViewModel = pageModelData,
ModelId = pageModelData.Id,
ModelType = modelType,
PropertyValidation = new Validation
{
MainSchema = SemanticMapping.GetSchema(pageModelData.SchemaId, localization),
InheritedSchemas = GetInheritedSemanticSchemas(pageModelData, localization)
},
MetadataFields = pageModelData.Metadata,
Localization = localization
};
pageModel = (PageModel)CreateViewModel(mappingData);
}
pageModel.MvcData = mvcData;
pageModel.Meta = pageModelData.Meta ?? new Dictionary <string, string>();
pageModel.Title = PostProcessPageTitle(pageModelData, localization); // TODO TSI-2210: This should eventually be done in Model Service.
pageModel.Url = pageModelData.UrlPath;
if (pageModelData.Regions != null)
{
IEnumerable <RegionModelData> regions = includePageRegions ? pageModelData.Regions : pageModelData.Regions.Where(r => r.IncludePageId == null);
pageModel.Regions.UnionWith(regions.Select(data => CreateRegionModel(data, localization)));
pageModel.IsVolatile |= pageModel.Regions.Any(region => region.IsVolatile);
}
}
}
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 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);
}
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);
}
protected virtual Type GetViewType(MvcData viewData)
{
return(ModelTypeRegistry.GetViewModelType(viewData));
}
