/// <summary>
/// Maps a batch of the same type of page module data to a collection
/// of display models ready for rendering.
/// </summary>
/// <param name="typeName">The module type name e.g. 'PlainText', 'RawHtml'.</param>
/// <param name="versionModule">The version data to get the serialized model from.</param>
/// <param name="workflowStatus">
/// The workflow status of the parent page or custom entity
/// being mapped. This is provided so dependent entities can use
/// the same workflow status.
/// </param>
/// <returns>
/// Collection of mapped display models, wrapped in an output class that
/// can be used to identify them.
/// </returns>
public List <PageModuleDisplayModelMapperOutput> MapDisplayModel(
string typeName,
IEnumerable <IEntityVersionPageModule> versionModules,
WorkFlowStatusQuery workflowStatus
)
{
// Find the data-provider class for this type of module
Type modelType = _moduleDataModelTypeFactory.CreateByPageModuleTypeFileName(typeName);
if (typeof(IPageModuleDisplayModel).IsAssignableFrom(modelType))
{
// We can serialize directly to the display model
var displayModels = new List <PageModuleDisplayModelMapperOutput>();
foreach (var pageModule in versionModules)
{
var mapperModel = new PageModuleDisplayModelMapperOutput();
mapperModel.DisplayModel = (IPageModuleDisplayModel)_dbUnstructuredDataSerializer.Deserialize(pageModule.SerializedData, modelType);
mapperModel.VersionModuleId = pageModule.GetVersionModuleId();
displayModels.Add(mapperModel);
}
return(displayModels);
}
else
{
var moduleWorkflowStatus = TranslateWorkFlowStatusForModules(workflowStatus);
// We have to use a mapping class to do some custom mapping
var displayModels = (List <PageModuleDisplayModelMapperOutput>)_mapGenericMethod
.MakeGenericMethod(modelType)
.Invoke(this, new object[] { versionModules, moduleWorkflowStatus });
return(displayModels);
}
}
/// <summary>
/// Maps a batch of the same type of page block data to a collection
/// of display models ready for rendering.
/// </summary>
/// <param name="typeName">The block type name e.g. 'PlainText', 'RawHtml'.</param>
/// <param name="pageBlocks">The version data to get the serialized model from.</param>
/// <param name="publishStatus">
/// The publish status of the parent page or custom entity
/// being mapped. This is provided so dependent entities can use
/// the same publish status.
/// </param>
/// <returns>
/// Collection of mapped display models, wrapped in an output class that
/// can be used to identify them.
/// </returns>
public async Task <ICollection <PageBlockTypeDisplayModelMapperOutput> > MapDisplayModelAsync(
string typeName,
IEnumerable <IEntityVersionPageBlock> pageBlocks,
PublishStatusQuery publishStatus
)
{
// Find the data-provider class for this block type
Type modelType = _pageBlockDataModelTypeFactory.CreateByPageBlockTypeFileName(typeName);
if (typeof(IPageBlockTypeDisplayModel).IsAssignableFrom(modelType))
{
// We can serialize directly to the display model
var displayModels = new List <PageBlockTypeDisplayModelMapperOutput>();
foreach (var pageBlock in pageBlocks)
{
var mapperModel = new PageBlockTypeDisplayModelMapperOutput();
mapperModel.DisplayModel = (IPageBlockTypeDisplayModel)_dbUnstructuredDataSerializer.Deserialize(pageBlock.SerializedData, modelType);
mapperModel.VersionBlockId = pageBlock.GetVersionBlockId();
displayModels.Add(mapperModel);
}
return(displayModels);
}
else
{
var blockWorkflowStatus = publishStatus.ToRelatedEntityQueryStatus();
// We have to use a mapping class to do some custom mapping
var displayModels = (Task <List <PageBlockTypeDisplayModelMapperOutput> >)_mapGenericMethod
.MakeGenericMethod(modelType)
.Invoke(this, new object[] { pageBlocks, blockWorkflowStatus });
return(await displayModels);
}
}
public async Task <UpdateCustomEntityDraftVersionCommand> ExecuteAsync(GetPatchableCommandByIdQuery <UpdateCustomEntityDraftVersionCommand> query, IExecutionContext executionContext)
{
var dbResult = await _dbContext
.CustomEntityVersions
.Include(v => v.CustomEntity)
.AsNoTracking()
.FilterActive()
.FilterByCustomEntityId(query.Id)
.Where(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft)
.SingleOrDefaultAsync();
if (dbResult == null)
{
return(null);
}
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityReadPermission>(dbResult.CustomEntity.CustomEntityDefinitionCode, executionContext.UserContext);
var command = new UpdateCustomEntityDraftVersionCommand()
{
CustomEntityDefinitionCode = dbResult.CustomEntity.CustomEntityDefinitionCode,
CustomEntityId = dbResult.CustomEntityId,
Title = dbResult.Title
};
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(command.CustomEntityDefinitionCode);
var definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
EntityNotFoundException.ThrowIfNull(definition, command.CustomEntityDefinitionCode);
command.Model = (ICustomEntityDataModel)_dbUnstructuredDataSerializer.Deserialize(dbResult.SerializedData, definition.DataModelType);
return(command);
}
private void MapDataModel(GetByIdQuery <CustomEntityDetails> query, CustomEntityVersion dbVersion, CustomEntityVersionDetails version)
{
var definition = _queryExecutor.GetById <CustomEntityDefinitionSummary>(dbVersion.CustomEntity.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, dbVersion.CustomEntity.CustomEntityDefinitionCode);
version.Model = (ICustomEntityVersionDataModel)_dbUnstructuredDataSerializer.Deserialize(dbVersion.SerializedData, definition.DataModelType);
}
public ICustomEntityDataModel Map(string customEntityDefinitionCode, string serializedData)
{
var definition = _customEntityDefinitions.SingleOrDefault(d => d.CustomEntityDefinitionCode == customEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, customEntityDefinitionCode);
var dataModelType = definition.GetDataModelType();
return((ICustomEntityDataModel)_dbUnstructuredDataSerializer.Deserialize(serializedData, dataModelType));
}
/// <summary>
/// Maps a batch of the same type of page block data to a collection
/// of display models ready for rendering.
/// </summary>
/// <param name="typeName">The block type name e.g. 'PlainText', 'RawHtml'.</param>
/// <param name="entityBlocks">The version data to get the serialized model from.</param>
/// <param name="publishStatus">
/// The publish status of the parent page or custom entity
/// being mapped. This is provided so dependent entities can use
/// the same publish status.
/// </param>
/// <param name="executionContext">
/// The execution context from the caller which can be used in
/// any child queries to ensure any elevated permissions are
/// passed down the chain of execution.
/// </param>
/// <returns>
/// Dictionary of mapped display models, with a key (block version id) that can be
/// used to identify them.
/// </returns>
public virtual async Task <IReadOnlyDictionary <int, IPageBlockTypeDisplayModel> > MapDisplayModelAsync(
string typeName,
IEnumerable <IEntityVersionPageBlock> entityBlocks,
PublishStatusQuery publishStatus,
IExecutionContext executionContext
)
{
// Find the data-provider class for this block type
Type modelType = _pageBlockDataModelTypeFactory.CreateByPageBlockTypeFileName(typeName);
if (typeof(IPageBlockTypeDisplayModel).IsAssignableFrom(modelType))
{
// We can serialize directly to the display model
var displayModels = new Dictionary <int, IPageBlockTypeDisplayModel>();
foreach (var pageBlock in entityBlocks)
{
var displayModel = (IPageBlockTypeDisplayModel)_dbUnstructuredDataSerializer.Deserialize(pageBlock.SerializedData, modelType);
var versionBlockId = pageBlock.GetVersionBlockId();
if (displayModels.ContainsKey(versionBlockId))
{
throw new Exception($"A block with a version id of {versionBlockId} has already been added to the mapping collection.");
}
displayModels.Add(versionBlockId, displayModel);
}
return(displayModels);
}
else
{
var blockWorkflowStatus = publishStatus.ToRelatedEntityQueryStatus();
// We have to use a mapping class to do some custom mapping
var displayModels = (Task <IReadOnlyDictionary <int, IPageBlockTypeDisplayModel> >)_mapGenericMethod
.MakeGenericMethod(modelType)
.Invoke(this, new object[] { entityBlocks, blockWorkflowStatus, executionContext });
return(await displayModels);
}
}
public async Task <PagedQueryResult <CustomEntitySummary> > ExecuteAsync(SearchCustomEntitySummariesQuery query, IExecutionContext executionContext)
{
var definition = _queryExecutor.GetById <CustomEntityDefinitionSummary>(query.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, query.CustomEntityDefinitionCode);
// Get Query
var dbQuery = GetQuery(query, definition);
// Execute Query
var dbPagedResult = dbQuery.ToPagedResult(query);
var routingsQuery = new GetPageRoutingInfoByCustomEntityIdRangeQuery(dbPagedResult.Items.Select(e => e.CustomEntityId));
var routings = await _queryExecutor.ExecuteAsync(routingsQuery);
var allLocales = (await _queryExecutor.GetAllAsync <ActiveLocale>()).ToDictionary(l => l.LocaleId);
// Map Items
var entities = new List <CustomEntitySummary>(dbPagedResult.Items.Length);
foreach (var dbVersion in dbPagedResult.Items)
{
PageRoutingInfo detailsRouting = null;
if (routings.ContainsKey(dbVersion.CustomEntityId))
{
detailsRouting = routings[dbVersion.CustomEntityId].FirstOrDefault(r => r.CustomEntityRouteRule != null);
}
var entity = Mapper.Map <CustomEntitySummary>(dbVersion);
if (dbVersion.LocaleId.HasValue)
{
entity.Locale = allLocales.GetOrDefault(dbVersion.LocaleId.Value);
EntityNotFoundException.ThrowIfNull(entity.Locale, dbVersion.LocaleId.Value);
}
if (detailsRouting != null)
{
entity.FullPath = detailsRouting.CustomEntityRouteRule.MakeUrl(detailsRouting.PageRoute, detailsRouting.CustomEntityRoute);
}
entity.Model = (ICustomEntityVersionDataModel)_dbUnstructuredDataSerializer.Deserialize(dbVersion.SerializedData, definition.DataModelType);
entity.AuditData.UpdateDate = dbVersion.VersionAuditData.CreateDate;
entity.AuditData.Updater = dbVersion.VersionAuditData.Creator;
entities.Add(entity);
}
return(dbPagedResult.ChangeType(entities));
}
private async Task MapDataModelAsync(
GetCustomEntityDetailsByIdQuery query,
CustomEntityVersion dbVersion,
CustomEntityVersionDetails version,
IExecutionContext executionContext
)
{
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(dbVersion.CustomEntity.CustomEntityDefinitionCode);
var definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
EntityNotFoundException.ThrowIfNull(definition, dbVersion.CustomEntity.CustomEntityDefinitionCode);
version.Model = (ICustomEntityDataModel)_dbUnstructuredDataSerializer.Deserialize(dbVersion.SerializedData, definition.DataModelType);
}
public T FindSetting <T>(string key, Dictionary <string, string> allSettings)
{
if (!allSettings.ContainsKey(key))
{
return(default(T));
}
var setting = allSettings[key];
if (string.IsNullOrWhiteSpace(setting))
{
return(default(T));
}
var value = _dbUnstructuredDataSerializer.Deserialize <T>(setting);
return(value);
}
public async Task <UpdateCustomEntityDraftVersionCommand> ExecuteAsync(GetByIdQuery <UpdateCustomEntityDraftVersionCommand> query, IExecutionContext executionContext)
{
var dbResult = await _dbContext
.CustomEntityVersions
.Include(v => v.CustomEntity)
.AsNoTracking()
.Where(v => v.CustomEntityId == query.Id && v.WorkFlowStatusId == (int)WorkFlowStatus.Draft)
.SingleOrDefaultAsync();
if (dbResult == null)
{
return(null);
}
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityReadPermission>(dbResult.CustomEntity.CustomEntityDefinitionCode);
var command = Mapper.Map <UpdateCustomEntityDraftVersionCommand>(dbResult);
var definition = _queryExecutor.GetById <CustomEntityDefinitionSummary>(command.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, command.CustomEntityDefinitionCode);
command.Model = (ICustomEntityVersionDataModel)_dbUnstructuredDataSerializer.Deserialize(dbResult.SerializedData, definition.DataModelType);
return(command);
}
/// <summary>
/// Maps a collection of EF CustomEntityVersion records from the db into CustomEntitySummary
/// objects.
/// </summary>
/// <param name="dbStatusQueries">Collection of versions to map.</param>
public async Task <List <CustomEntitySummary> > MapAsync(ICollection <CustomEntityPublishStatusQuery> dbStatusQueries, IExecutionContext executionContext)
{
var entities = new List <CustomEntitySummary>(dbStatusQueries.Count);
var routingsQuery = new GetPageRoutingInfoByCustomEntityIdRangeQuery(dbStatusQueries.Select(e => e.CustomEntityId));
var routings = await _queryExecutor.ExecuteAsync(routingsQuery, executionContext);
Dictionary <int, ActiveLocale> allLocales = null;
Dictionary <string, CustomEntityDefinitionSummary> customEntityDefinitions = new Dictionary <string, CustomEntityDefinitionSummary>();
var hasCheckedQueryValid = false;
foreach (var dbStatusQuery in dbStatusQueries)
{
// Validate the input data
if (!hasCheckedQueryValid)
{
ValidateQuery(dbStatusQuery);
}
hasCheckedQueryValid = true;
// Easy mappings
var entity = new CustomEntitySummary()
{
AuditData = _auditDataMapper.MapUpdateAuditDataCreatorData(dbStatusQuery.CustomEntity),
CustomEntityDefinitionCode = dbStatusQuery.CustomEntity.CustomEntityDefinitionCode,
CustomEntityId = dbStatusQuery.CustomEntityId,
HasDraft = dbStatusQuery.CustomEntityVersion.WorkFlowStatusId == (int)WorkFlowStatus.Draft,
PublishStatus = PublishStatusMapper.FromCode(dbStatusQuery.CustomEntity.PublishStatusCode),
PublishDate = DbDateTimeMapper.AsUtc(dbStatusQuery.CustomEntity.PublishDate),
Ordering = dbStatusQuery.CustomEntity.Ordering,
Title = dbStatusQuery.CustomEntityVersion.Title,
UrlSlug = dbStatusQuery.CustomEntity.UrlSlug
};
entity.IsPublished = entity.PublishStatus == PublishStatus.Published && entity.PublishDate <= executionContext.ExecutionDate;
_auditDataMapper.MapUpdateAuditDataUpdaterData(entity.AuditData, dbStatusQuery.CustomEntityVersion);
// Routing data (if any)
PageRoutingInfo detailsRouting = null;
if (routings.ContainsKey(dbStatusQuery.CustomEntityId))
{
detailsRouting = routings[dbStatusQuery.CustomEntityId].FirstOrDefault(r => r.CustomEntityRouteRule != null);
entity.FullPath = detailsRouting?.CustomEntityRouteRule?.MakeUrl(detailsRouting.PageRoute, detailsRouting.CustomEntityRoute);
}
// Locale data
var localeId = dbStatusQuery.CustomEntity.LocaleId;
if (localeId.HasValue && detailsRouting != null)
{
entity.Locale = detailsRouting.PageRoute.Locale;
EntityNotFoundException.ThrowIfNull(entity.Locale, localeId.Value);
}
else if (localeId.HasValue)
{
// Lazy load locales, since they aren't always used
if (allLocales == null)
{
allLocales = await GetLocalesAsync(executionContext);
}
entity.Locale = allLocales.GetOrDefault(localeId.Value);
EntityNotFoundException.ThrowIfNull(entity.Locale, localeId.Value);
}
// Parse model data
var definition = customEntityDefinitions.GetOrDefault(dbStatusQuery.CustomEntity.CustomEntityDefinitionCode);
if (definition == null)
{
// Load and cache definitions
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(dbStatusQuery.CustomEntity.CustomEntityDefinitionCode);
definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
EntityNotFoundException.ThrowIfNull(definition, definition.CustomEntityDefinitionCode);
customEntityDefinitions.Add(dbStatusQuery.CustomEntity.CustomEntityDefinitionCode, definition);
}
entity.Model = (ICustomEntityDataModel)_dbUnstructuredDataSerializer.Deserialize(dbStatusQuery.CustomEntityVersion.SerializedData, definition.DataModelType);
entities.Add(entity);
}
return(entities);
}
public async Task <List <CustomEntitySummary> > MapAsync(ICollection <CustomEntityPublishStatusQuery> dbCustomEntities, IExecutionContext executionContext)
{
var entities = new List <CustomEntitySummary>(dbCustomEntities.Count);
var routingsQuery = new GetPageRoutingInfoByCustomEntityIdRangeQuery(dbCustomEntities.Select(e => e.CustomEntityId));
var routings = await _queryExecutor.ExecuteAsync(routingsQuery, executionContext);
Dictionary <int, ActiveLocale> allLocales = null;
var customEntityDefinitions = new Dictionary <string, CustomEntityDefinitionSummary>();
var hasCheckedQueryValid = false;
foreach (var dbCustomEntity in dbCustomEntities)
{
// Validate the input data
if (!hasCheckedQueryValid)
{
ValidateQuery(dbCustomEntity);
}
hasCheckedQueryValid = true;
// Easy mappings
var entity = MapBasicProperties(dbCustomEntity);
// Routing data (if any)
var detailsRouting = FindRoutingData(routings, dbCustomEntity);
if (detailsRouting != null)
{
entity.FullUrlPath = detailsRouting.CustomEntityRouteRule.MakeUrl(detailsRouting.PageRoute, detailsRouting.CustomEntityRoute);
entity.HasPublishedVersion = detailsRouting.CustomEntityRoute.HasPublishedVersion;
}
// Locale data
var localeId = dbCustomEntity.CustomEntity.LocaleId;
if (localeId.HasValue && detailsRouting != null)
{
entity.Locale = detailsRouting.PageRoute.Locale;
EntityNotFoundException.ThrowIfNull(entity.Locale, localeId.Value);
}
else if (localeId.HasValue)
{
// Lazy load locales, since they aren't always used
if (allLocales == null)
{
allLocales = await GetLocalesAsync(executionContext);
}
entity.Locale = allLocales.GetOrDefault(localeId.Value);
EntityNotFoundException.ThrowIfNull(entity.Locale, localeId.Value);
}
// Parse model data
var definition = customEntityDefinitions.GetOrDefault(dbCustomEntity.CustomEntity.CustomEntityDefinitionCode);
if (definition == null)
{
// Load and cache definitions
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(dbCustomEntity.CustomEntity.CustomEntityDefinitionCode);
definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
EntityNotFoundException.ThrowIfNull(definition, definition.CustomEntityDefinitionCode);
customEntityDefinitions.Add(dbCustomEntity.CustomEntity.CustomEntityDefinitionCode, definition);
}
entity.Model = (ICustomEntityDataModel)_dbUnstructuredDataSerializer.Deserialize(dbCustomEntity.CustomEntityVersion.SerializedData, definition.DataModelType);
entities.Add(entity);
}
await EnsureHasPublishedVersionSet(entities);
return(entities);
}
