/// <summary>
/// Parameters for mapping an ICustomEntityPageViewModel using an
/// IPageViewModelMapper implementation.
/// </summary>
/// <param name="page">The page data to include in the view model.</param>
/// <param name="visualEditorMode">The view mode requested by the visual editor or a default value.</param>
/// <param name="customEntityModel">he custom entity model data to use in the mapping.</param>
public CustomEntityPageViewModelBuilderParameters(
PageRenderDetails page,
VisualEditorMode visualEditorMode,
CustomEntityRenderDetails customEntityModel
)
: base(page, visualEditorMode)
{
CustomEntityModel = customEntityModel;
}
public IEditablePageViewModel MapCustomEntityModel(
Type displayModelType,
PageRenderDetails page,
CustomEntityRenderDetails customEntityRenderDetails,
VisualEditorMode siteViewerMode)
{
return((IEditablePageViewModel)_mapMethod
.MakeGenericMethod(displayModelType)
.Invoke(this, new object[] { page, customEntityRenderDetails, siteViewerMode }));
}
public Task <BlogPostPageDisplayModel> MapDisplayModelAsync(CustomEntityRenderDetails entity, BlogPostDataModel dataModel, PublishStatusQuery publishStatusQuery)
{
var displayModel = new BlogPostPageDisplayModel();
displayModel.PageTitle = entity.Title;
displayModel.MetaDescription = dataModel.ShortDescription;
displayModel.ShortDescription = dataModel.ShortDescription;
return(Task.FromResult(displayModel));
}
/// <summary>
/// Maps custom entity render data into a specific custom entity
/// display model type, which can be used to render out view data.
/// </summary>
/// <typeparam name="TDisplayModel">Display model type to map to.</typeparam>
/// <param name="renderDetails">The custom entity model to map, including the raw data model.</param>
/// <param name="publishStatusQuery">
/// The query type that should be used to query dependent entities. E.g. if the custom
/// entity was queried with the Published status query, then any dependent entities should
/// also be queried as Published.
/// </param>
/// <returns>Mapped display model instance.</returns>
public Task <TDisplayModel> MapDisplayModelAsync <TDisplayModel>(
CustomEntityRenderDetails renderDetails,
PublishStatusQuery publishStatusQuery
)
where TDisplayModel : ICustomEntityDisplayModel
{
var mapperType = typeof(ICustomEntityDisplayModelMapper <,>).MakeGenericType(renderDetails.Model.GetType(), typeof(TDisplayModel));
var mapper = _serviceProvider.GetRequiredService(mapperType);
var method = mapperType.GetMethod(mapDisplayModelMethodName);
return((Task <TDisplayModel>)method.Invoke(mapper, new object[] { renderDetails, renderDetails.Model, publishStatusQuery }));
}
public Task <TestCustomEntityPageDisplayModel> MapDisplayModelAsync(
CustomEntityRenderDetails renderDetails,
TestCustomEntityDataModel dataModel,
PublishStatusQuery publishStatusQuery
)
{
var displayModel = new TestCustomEntityPageDisplayModel()
{
PageTitle = renderDetails.Title,
MetaDescription = "Test Meta Description"
};
return(Task.FromResult(displayModel));
}
/// <summary>
/// Maps a raw custom entity data model to a display model that can be rendered out
/// to a view template.
/// </summary>
/// <param name="renderDetails">
/// The raw custom entity data pulled from the database.
/// </param>
/// <param name="dataModel">
/// Typed model data to map from. This is the same model that's in the render
/// details model, but is passed in as a typed model for easy access.
/// </param>
/// <param name="publishStatusQuery">
/// The query type that should be used to query dependent entities. E.g. if the custom
/// entity was queried with the Published status query, then any dependent entities should
/// also be queried as Published.
/// </param>
public async Task <BlogPostDisplayModel> MapDisplayModelAsync(
CustomEntityRenderDetails renderDetails,
BlogPostDataModel dataModel,
PublishStatusQuery publishStatusQuery
)
{
var vm = new BlogPostDisplayModel()
{
MetaDescription = dataModel.ShortDescription,
PageTitle = renderDetails.Title,
Title = renderDetails.Title,
Date = renderDetails.CreateDate,
FullPath = renderDetails.PageUrls.FirstOrDefault()
};
vm.Categories = await MapCategories(dataModel, publishStatusQuery);
vm.Author = await MapAuthor(dataModel, publishStatusQuery);
return(vm);
}
private CustomEntityDetailsPageViewModel <TDisplayModel> MapCustomEntityModel <TDisplayModel>(
PageRenderDetails page,
CustomEntityRenderDetails customEntityRenderDetails,
VisualEditorMode siteViewerMode
) where TDisplayModel : ICustomEntityDetailsDisplayViewModel
{
var vm = Map <CustomEntityDetailsPageViewModel <TDisplayModel> >(page, siteViewerMode);
var customModel = new CustomEntityRenderDetailsViewModel <TDisplayModel>();
customModel.CustomEntityId = customEntityRenderDetails.CustomEntityId;
customModel.CustomEntityVersionId = customEntityRenderDetails.CustomEntityVersionId;
customModel.Locale = customEntityRenderDetails.Locale;
customModel.Sections = customEntityRenderDetails.Sections;
customModel.Title = customEntityRenderDetails.Title;
customModel.UrlSlug = customEntityRenderDetails.UrlSlug;
customModel.WorkFlowStatus = customEntityRenderDetails.WorkFlowStatus;
customModel.Model = _customEntityDisplayModelMapper.MapDetails <TDisplayModel>(customEntityRenderDetails);
vm.CustomEntity = customModel;
return(vm);
}
