/// <summary>
/// Populates a Dynamic List by executing the query it specifies.
/// </summary>
/// <param name="dynamicList">The Dynamic List which specifies the query and is to be populated.</param>
/// <param name="localization">The context Localization.</param>
public void PopulateDynamicList(DynamicList dynamicList, Localization localization)
{
using (new Tracer(dynamicList, localization))
{
SimpleBrokerQuery simpleBrokerQuery = dynamicList.GetQuery(localization) as SimpleBrokerQuery;
if (simpleBrokerQuery == null)
{
throw new DxaException($"Unexpected result from {dynamicList.GetType().Name}.GetQuery: {dynamicList.GetQuery(localization)}");
}
BrokerQuery brokerQuery = new BrokerQuery(simpleBrokerQuery);
string[] componentUris = brokerQuery.ExecuteQuery().ToArray();
Log.Debug($"Broker Query returned {componentUris.Length} results. HasMore={brokerQuery.HasMore}");
if (componentUris.Length > 0)
{
Type resultType = dynamicList.ResultType;
ComponentMetaFactory componentMetaFactory = new ComponentMetaFactory(localization.GetCmUri());
dynamicList.QueryResults = componentUris
.Select(c => ModelBuilderPipelineR2.CreateEntityModel(CreateEntityModelData(componentMetaFactory.GetMeta(c)), resultType, localization))
.ToList();
}
dynamicList.HasMore = brokerQuery.HasMore;
}
}
private static object MapRichText(RichTextData richTextData, Type targetType, Localization localization)
{
IList <IRichTextFragment> fragments = new List <IRichTextFragment>();
foreach (object fragment in richTextData.Fragments)
{
string htmlFragment = fragment as string;
if (htmlFragment == null)
{
// Embedded Entity Model (for Media Items)
MediaItem mediaItem = (MediaItem)ModelBuilderPipelineR2.CreateEntityModel((EntityModelData)fragment, typeof(MediaItem), localization);
mediaItem.IsEmbedded = true;
if (mediaItem.MvcData == null)
{
mediaItem.MvcData = mediaItem.GetDefaultView(localization);
}
fragments.Add(mediaItem);
}
else
{
// HTML fragment.
fragments.Add(new RichTextFragment(htmlFragment));
}
}
RichText richText = new RichText(fragments);
if (targetType == typeof(RichText))
{
return(richText);
}
return(richText.ToString());
}
private PageModel LoadPageModel(ref string urlPath, bool addIncludes, Localization localization)
{
using (new Tracer(urlPath, addIncludes, localization))
{
PageModelData pageModelData = _modelService.GetPageModelData(urlPath, localization, addIncludes);
if (pageModelData == null)
{
throw new DxaItemNotFoundException(urlPath);
}
if (pageModelData.MvcData == null)
{
throw new DxaException($"Data Model for Page '{pageModelData.Title}' ({pageModelData.Id}) contains no MVC data. Ensure that the Page is published using the DXA R2 TBBs.");
}
return(ModelBuilderPipelineR2.CreatePageModel(pageModelData, addIncludes, localization));
}
}
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);
}
private EntityModel LoadEntityModel(string id, Localization localization)
{
using (new Tracer(id, localization))
{
EntityModelData entityModelData = _modelService.GetEntityModelData(id, localization);
if (entityModelData == null)
{
throw new DxaItemNotFoundException(id);
}
EntityModel result = ModelBuilderPipelineR2.CreateEntityModel(entityModelData, null, localization);
if (result.XpmMetadata != null)
{
// Entity Models requested through this method are per definition "query based" in XPM terminology.
result.XpmMetadata["IsQueryBased"] = true; // TODO TSI-24: Do this in Model Service (or CM-side?)
}
return(result);
}
}
private static 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}'.");
}
return(ModelBuilderPipelineR2.CreateEntityModel(entityModelData, targetType, localization));
}
