public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <DocumentDataModel> context,
PageBlockTypeDisplayModelMapperResult <DocumentDataModel> result
)
{
var documentIds = context.Items.SelectDistinctModelValuesWithoutEmpty(i => i.DocumentAssetId);
var documentsQuery = new GetDocumentAssetRenderDetailsByIdRangeQuery(documentIds);
var documents = await _queryExecutor.ExecuteAsync(documentsQuery, context.ExecutionContext);
foreach (var item in context.Items)
{
var document = documents.GetOrDefault(item.DataModel.DocumentAssetId);
var displayModel = new DocumentDisplayModel();
if (document != null)
{
displayModel.Description = document.Description;
displayModel.Title = document.Title;
if (item.DataModel.DownloadMode == DocumentDownloadMode.ForceDownload)
{
displayModel.Url = _documentAssetRouteLibrary.DocumentAssetDownload(document);
}
else
{
displayModel.Url = _documentAssetRouteLibrary.DocumentAsset(document);
}
}
result.Add(item, displayModel);
}
}
protected async Task <IReadOnlyDictionary <int, IPageBlockTypeDisplayModel> > MapGeneric <TDataModel>(
IEnumerable <IEntityVersionPageBlock> pageBlocks,
PublishStatusQuery publishStatusQuery,
IExecutionContext executionContext
) where TDataModel : IPageBlockTypeDataModel
{
var mapperType = typeof(IPageBlockTypeDisplayModelMapper <TDataModel>);
var mapper = (IPageBlockTypeDisplayModelMapper <TDataModel>)_serviceProvider.GetService(mapperType);
if (mapper == null)
{
string msg = @"{0} does not implement IPageBlockDisplayModel and no custom mapper could be found. You must create
a class that implements IPageBlockDisplayModelMapper<{0}> if you are using a custom display model. Full type name: {1}";
throw new Exception(string.Format(msg, typeof(TDataModel).Name, typeof(TDataModel).FullName));
}
var dataModels = new List <PageBlockTypeDisplayModelMapperInput <TDataModel> >();
foreach (var pageBlock in pageBlocks)
{
var mapperModel = new PageBlockTypeDisplayModelMapperInput <TDataModel>();
mapperModel.DataModel = (TDataModel)_dbUnstructuredDataSerializer.Deserialize(pageBlock.SerializedData, typeof(TDataModel));
mapperModel.VersionBlockId = pageBlock.GetVersionBlockId();
dataModels.Add(mapperModel);
}
var context = new PageBlockTypeDisplayModelMapperContext <TDataModel>(dataModels, publishStatusQuery, executionContext);
var result = new PageBlockTypeDisplayModelMapperResult <TDataModel>(dataModels.Count);
await mapper.MapAsync(context, result);
return(result.Items);
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <DirectoryListDataModel> context,
PageBlockTypeDisplayModelMapperResult <DirectoryListDataModel> result
)
{
foreach (var item in context.Items)
{
var query = new SearchPageRenderSummariesQuery();
query.PageDirectoryId = item.DataModel.PageDirectoryId;
query.PageSize = item.DataModel.PageSize;
// Pass through the workflow status so that we only show published pages
// when viewing the live site.
query.PublishStatus = context.PublishStatusQuery;
var displayModel = new DirectoryListDisplayModel();
displayModel.Pages = await _contentRepository
.WithExecutionContext(context.ExecutionContext)
.Pages()
.Search()
.AsRenderSummaries(query)
.ExecuteAsync();
result.Add(item, displayModel);
}
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <PageListDataModel> context,
PageBlockTypeDisplayModelMapperResult <PageListDataModel> result
)
{
var allPageIds = context.Items.SelectManyDistinctModelValues(m => m.PageIds);
// Page routes are cached and so are the quickest way to get simple page information.
// If we needed more data we could use a different but slower query to get it.
var allPageRoutes = await _contentRepository
.WithContext(context.ExecutionContext)
.Pages()
.GetByIdRange(allPageIds)
.AsRoutes()
.ExecuteAsync();
foreach (var item in context.Items)
{
var displayModel = new PageListDisplayModel();
// Here will get the relevant pages and order them correctly.
// Additionally if we are viewing the published version of the page
// then we make sure we only show published pages in the list.
displayModel.Pages = allPageRoutes
.FilterAndOrderByKeys(item.DataModel.PageIds)
.Where(p => context.PublishStatusQuery != PublishStatusQuery.Published || p.IsPublished())
.ToList();
result.Add(item, displayModel);
}
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <PageListDataModel> context,
PageBlockTypeDisplayModelMapperResult <PageListDataModel> result
)
{
var allPageIds = context.Items.SelectManyDistinctModelValues(d => d.PageIds);
// Page routes are cached and so are the quickest way to get simple page information.
// If we needed more data we could use a different but slower query to get it.
var query = new GetPageRenderSummariesByIdRangeQuery(allPageIds, context.PublishStatusQuery);
var allPageRoutes = await _contentRepository
.WithExecutionContext(context.ExecutionContext)
.Pages()
.GetByIdRange(allPageIds)
.AsRenderSummaries(context.PublishStatusQuery)
.ExecuteAsync();
foreach (var item in context.Items)
{
var mapped = new PageListDisplayModel();
// Here will get the relevant pages and order them correctly.
mapped.Pages = allPageRoutes
.FilterAndOrderByKeys(item.DataModel.PageIds)
.ToList();
result.Add(item, mapped);
}
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <CarouselDataModel> context,
PageBlockTypeDisplayModelMapperResult <CarouselDataModel> result
)
{
// Find all the image ids to load
var allImageAssetIds = context
.Items
.SelectMany(m => m.DataModel.Slides)
.Select(m => m.ImageId)
.Where(i => i > 0)
.Distinct();
// Load image data
var allImages = await _imageAssetRepository.GetImageAssetRenderDetailsByIdRangeAsync(allImageAssetIds, context.ExecutionContext);
// Map display model
foreach (var items in context.Items)
{
var output = new CarouselDisplayModel();
output.Slides = EnumerableHelper
.Enumerate(items.DataModel.Slides)
.Select(m => new CarouselSlideDisplayModel()
{
Image = allImages.GetOrDefault(m.ImageId),
Text = m.Text,
Title = m.Title
})
.ToList();
result.Add(items, output);
}
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <ContentSplitSectionDataModel> context,
PageBlockTypeDisplayModelMapperResult <ContentSplitSectionDataModel> result
)
{
// Because mapping is done in batch, we have to map multiple images here
// The Cofoundry IContentRepository gives us an easy to use data access api.
// for us
var imageAssetIds = context.Items.SelectDistinctModelValuesWithoutEmpty(i => i.ImageAssetId);
var imageAssets = await _contentRepository
.WithExecutionContext(context.ExecutionContext)
.ImageAssets()
.GetByIdRange(imageAssetIds)
.AsRenderDetails()
.ExecuteAsync();
foreach (var item in context.Items)
{
var displayModel = new ContentSplitSectionDisplayModel();
displayModel.HtmlText = new HtmlString(item.DataModel.HtmlText);
displayModel.Title = item.DataModel.Title;
displayModel.Image = imageAssets.GetOrDefault(item.DataModel.ImageAssetId);
result.Add(item, displayModel);
}
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <PageSnippetDataModel> context,
PageBlockTypeDisplayModelMapperResult <PageSnippetDataModel> result
)
{
var allPageIds = context.Items.SelectDistinctModelValuesWithoutEmpty(m => m.PageId);
// The PageRenderDetails object contains page, template and block data targeting
// a specific version. We pass through the PublishStatusQuery to ensure this is
// respected when querying related data i.e. if we're viewing a draft version then we
// should also be able to see connected entities in draft status.
var pagesQuery = new GetPageRenderDetailsByIdRangeQuery(allPageIds, context.PublishStatusQuery);
var allPages = await _contentRepository
.WithExecutionContext(context.ExecutionContext)
.Pages()
.GetByIdRange(allPageIds)
.AsRenderDetails()
.ExecuteAsync();
foreach (var item in context.Items)
{
var displayModel = new PageSnippetDisplayModel();
displayModel.Page = allPages.GetOrDefault(item.DataModel.PageId);
// We have to code defensively here and bear in mind that the related
// entities may be in draft status and may not be available when viewing
// the live site.
if (displayModel.Page != null)
{
// An example of querying the block data. Here we find all the raw html
// page blocks and select all the data and strip out the html tags
var strippedHtml = displayModel
.Page
.Regions
.SelectMany(s => s.Blocks)
.Select(m => m.DisplayModel as RawHtmlDisplayModel)
.Where(m => m != null)
.Select(m => _htmlSanitizer.StripHtml(m.RawHtml));
// This is just an example of working with the data, in reality this
// would be much more dependent on your content.
var combinedText = string.Join(Environment.NewLine, strippedHtml);
displayModel.Snippet = TextFormatter.LimitWithElipsesOnWordBoundary(combinedText, 300);
}
// The CreateOutput() method wraps the mapped display
// model with it's identifier so we can identify later on
result.Add(item, displayModel);
}
}
public Task MapAsync(
PageBlockTypeDisplayModelMapperContext <RichTextDataModel> context,
PageBlockTypeDisplayModelMapperResult <RichTextDataModel> result
)
{
foreach (var item in context.Items)
{
var displayModel = new RichTextDisplayModel();
displayModel.RawHtml = new HtmlString(item.DataModel.RawHtml);
result.Add(item, displayModel);
}
return(Task.CompletedTask);
}
/// <summary>
/// A IPageModuleDisplayModelMapper class handles the mapping from
/// a display model to a data model.
///
/// The mapper supports DI which gives you flexibility in what data
/// you want to include in the display model and how you want to
/// map it. Mapping is done in batch to improve performance when
/// the same block type is used multiple times on a page.
/// </summary>
public Task MapAsync(
PageBlockTypeDisplayModelMapperContext <ContentSectionDataModel> context,
PageBlockTypeDisplayModelMapperResult <ContentSectionDataModel> result
)
{
foreach (var input in context.Items)
{
var output = new ContentSectionDisplayModel();
output.HtmlText = new HtmlString(input.DataModel.HtmlText);
output.Title = input.DataModel.Title;
result.Add(input, output);
}
return(Task.CompletedTask);
}
public Task MapAsync(
PageBlockTypeDisplayModelMapperContext <TextListDataModel> context,
PageBlockTypeDisplayModelMapperResult <TextListDataModel> result
)
{
foreach (var item in context.Items)
{
var displayModel = new TextListDisplayModel();
displayModel.TextListItems = item.DataModel.TextList.Split(LINE_DELIMITERS, StringSplitOptions.None);
displayModel.Title = item.DataModel.Title;
displayModel.IsNumbered = item.DataModel.IsNumbered;
result.Add(item, displayModel);
}
return(Task.CompletedTask);
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <ContentSplitSectionDataModel> context,
PageBlockTypeDisplayModelMapperResult <ContentSplitSectionDataModel> result
)
{
var imageAssetIds = context.Items.SelectDistinctModelValuesWithoutEmpty(i => i.ImageAssetId);
var imageAssets = await _imageAssetRepository.GetImageAssetRenderDetailsByIdRangeAsync(imageAssetIds, context.ExecutionContext);
foreach (var item in context.Items)
{
var displayModel = new ContentSplitSectionDisplayModel();
displayModel.HtmlText = new HtmlString(item.DataModel.HtmlText);
displayModel.Title = item.DataModel.Title;
displayModel.Image = imageAssets.GetOrDefault(item.DataModel.ImageAssetId);
result.Add(item, displayModel);
}
}
public Task MapAsync(
PageBlockTypeDisplayModelMapperContext <QuotationDataModel> context,
PageBlockTypeDisplayModelMapperResult <QuotationDataModel> result
)
{
foreach (var item in context.Items)
{
var displayModel = new QuotationDisplayModel();
displayModel.CitationText = item.DataModel.CitationText;
displayModel.CitationUrl = item.DataModel.CitationUrl;
displayModel.Quotation = new HtmlString(HtmlFormatter.ConvertLineBreaksToBrTags(item.DataModel.CitationText));
displayModel.Title = item.DataModel.Title;
result.Add(item, displayModel);
}
return(Task.CompletedTask);
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <ContentSplitSectionDataModel> context,
PageBlockTypeDisplayModelMapperResult <ContentSplitSectionDataModel> result
)
{
// Because mapping is done in batch, we have to map multiple images here
// Fortunately Cofoundry gives us access to repositories that can fetch this data
// for us
var imageAssetIds = context.Items.SelectDistinctModelValuesWithoutEmpty(i => i.ImageAssetId);
var imageAssets = await _imageAssetRepository.GetImageAssetRenderDetailsByIdRangeAsync(imageAssetIds, context.ExecutionContext);
foreach (var item in context.Items)
{
var displayModel = new ContentSplitSectionDisplayModel();
displayModel.HtmlText = new HtmlString(item.DataModel.HtmlText);
displayModel.Title = item.DataModel.Title;
displayModel.Image = imageAssets.GetOrDefault(item.DataModel.ImageAssetId);
result.Add(item, displayModel);
}
}
public async Task MapAsync(
PageBlockTypeDisplayModelMapperContext <ImageDataModel> context,
PageBlockTypeDisplayModelMapperResult <ImageDataModel> result
)
{
var imageAssetIds = context.Items.SelectDistinctModelValuesWithoutEmpty(i => i.ImageId);
var imagesQuery = new GetImageAssetRenderDetailsByIdRangeQuery(imageAssetIds);
var images = await _queryExecutor.ExecuteAsync(imagesQuery, context.ExecutionContext);
foreach (var item in context.Items)
{
var displayModel = new ImageDisplayModel()
{
AltText = item.DataModel.AltText,
LinkPath = item.DataModel.LinkPath,
LinkTarget = item.DataModel.LinkTarget
};
var image = images.GetOrDefault(item.DataModel.ImageId);
displayModel.Source = _imageAssetRouteLibrary.ImageAsset(image);
result.Add(item, displayModel);
}
}
