private CustomEntityDetails MapInitialData(CustomEntityVersion dbVersion, IExecutionContext executionContext)
{
var entity = new CustomEntityDetails()
{
CustomEntityId = dbVersion.CustomEntity.CustomEntityId,
UrlSlug = dbVersion.CustomEntity.UrlSlug,
PublishStatus = PublishStatusMapper.FromCode(dbVersion.CustomEntity.PublishStatusCode),
PublishDate = dbVersion.CustomEntity.PublishDate,
LastPublishDate = dbVersion.CustomEntity.LastPublishDate,
};
entity.AuditData = _auditDataMapper.MapCreateAuditData(dbVersion.CustomEntity);
entity.LatestVersion = new CustomEntityVersionDetails()
{
CustomEntityVersionId = dbVersion.CustomEntityVersionId,
Title = dbVersion.Title,
DisplayVersion = dbVersion.DisplayVersion,
WorkFlowStatus = (WorkFlowStatus)dbVersion.WorkFlowStatusId
};
entity.LatestVersion.AuditData = _auditDataMapper.MapCreateAuditData(dbVersion);
entity.HasDraftVersion = entity.LatestVersion.WorkFlowStatus == WorkFlowStatus.Draft;
return(entity);
}
private void UpdateDraft(UpdateCustomEntityDraftVersionCommand command, CustomEntityVersion draft)
{
EntityNotFoundException.ThrowIfNull(draft, "Draft:" + command.CustomEntityId);
draft.Title = command.Title.Trim();
draft.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.Model);
}
private async Task <CustomEntityDetails> MapAsync(
GetCustomEntityDetailsByIdQuery query,
CustomEntityVersion dbVersion,
IExecutionContext executionContext
)
{
if (dbVersion == null)
{
return(null);
}
var entity = MapInitialData(dbVersion, executionContext);
// Re-map IsPublished checking to see if there is a published version in the history
if (entity.IsPublished && entity.LatestVersion.WorkFlowStatus != WorkFlowStatus.Published)
{
entity.IsPublished = await _dbContext
.CustomEntityVersions
.AnyAsync(v => v.CustomEntityId == query.CustomEntityId && v.WorkFlowStatusId == (int)WorkFlowStatus.Published);
}
if (dbVersion.CustomEntity.LocaleId.HasValue)
{
var getLocaleQuery = new GetActiveLocaleByIdQuery(dbVersion.CustomEntity.LocaleId.Value);
entity.Locale = await _queryExecutor.ExecuteAsync(getLocaleQuery, executionContext);
}
// Custom Mapping
await MapDataModelAsync(query, dbVersion, entity.LatestVersion, executionContext);
await MapPages(dbVersion, entity, executionContext);
return(entity);
}
private async Task <CustomEntityDetails> Map(
GetByIdQuery <CustomEntityDetails> query,
CustomEntityVersion dbVersion,
IExecutionContext executionContext)
{
if (dbVersion == null)
{
return(null);
}
var entity = Mapper.Map <CustomEntityDetails>(dbVersion.CustomEntity);
entity.LatestVersion = Mapper.Map <CustomEntityVersionDetails>(dbVersion);
entity.HasDraft = entity.LatestVersion.WorkFlowStatus == WorkFlowStatus.Draft;
entity.IsPublished = entity.LatestVersion.WorkFlowStatus == WorkFlowStatus.Published;
if (!entity.IsPublished)
{
entity.IsPublished = await _dbContext
.CustomEntityVersions
.AnyAsync(v => v.CustomEntityId == query.Id && v.WorkFlowStatusId == (int)WorkFlowStatus.Published);
}
// Custom Mapping
MapDataModel(query, dbVersion, entity.LatestVersion);
await MapPages(dbVersion, entity, executionContext);
return(entity);
}
private CustomEntity MapEntity(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition, IExecutionContext executionContext)
{
var entity = new CustomEntity();
_entityAuditHelper.SetCreated(entity, executionContext);
entity.Locale = GetLocale(command.LocaleId);
entity.UrlSlug = command.UrlSlug;
entity.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
var version = new CustomEntityVersion();
version.Title = command.Title.Trim();
version.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.Model);
version.DisplayVersion = 1;
if (command.Publish)
{
entity.PublishStatusCode = PublishStatusCode.Published;
entity.PublishDate = command.PublishDate ?? executionContext.ExecutionDate;
version.WorkFlowStatusId = (int)WorkFlowStatus.Published;
}
else
{
entity.PublishStatusCode = PublishStatusCode.Unpublished;
entity.PublishDate = command.PublishDate;
version.WorkFlowStatusId = (int)WorkFlowStatus.Draft;
}
_entityAuditHelper.SetCreated(version, executionContext);
entity.CustomEntityVersions.Add(version);
return(entity);
}
private CustomEntityDetails MapInitialData(CustomEntityVersion dbVersion, IExecutionContext executionContext)
{
var entity = new CustomEntityDetails()
{
CustomEntityId = dbVersion.CustomEntity.CustomEntityId,
UrlSlug = dbVersion.CustomEntity.UrlSlug,
PublishStatus = PublishStatusMapper.FromCode(dbVersion.CustomEntity.PublishStatusCode),
PublishDate = DbDateTimeMapper.AsUtc(dbVersion.CustomEntity.PublishDate),
};
entity.IsPublished = entity.PublishStatus == PublishStatus.Published && entity.PublishDate <= executionContext.ExecutionDate;
entity.AuditData = _auditDataMapper.MapCreateAuditData(dbVersion.CustomEntity);
entity.LatestVersion = new CustomEntityVersionDetails()
{
CustomEntityVersionId = dbVersion.CustomEntityVersionId,
Title = dbVersion.Title,
WorkFlowStatus = (WorkFlowStatus)dbVersion.WorkFlowStatusId
};
entity.LatestVersion.AuditData = _auditDataMapper.MapCreateAuditData(dbVersion);
entity.HasDraft = entity.LatestVersion.WorkFlowStatus == WorkFlowStatus.Draft;
return(entity);
}
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);
}
private CustomEntityRenderDetails MapCustomEntity(CustomEntityVersion dbResult)
{
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityReadPermission>(dbResult.CustomEntity.CustomEntityDefinitionCode);
var entity = Mapper.Map <CustomEntityRenderDetails>(dbResult);
entity.Model = _customEntityDataModelMapper.Map(dbResult.CustomEntity.CustomEntityDefinitionCode, dbResult.SerializedData);
return(entity);
}
private Task OnTransactionComplete(CustomEntityVersion version)
{
_customEntityCache.Clear(version.CustomEntity.CustomEntityDefinitionCode, version.CustomEntityId);
return(_messageAggregator.PublishAsync(new CustomEntityPublishedMessage()
{
CustomEntityId = version.CustomEntityId,
CustomEntityDefinitionCode = version.CustomEntity.CustomEntityDefinitionCode
}));
}
private Task OnTransactionComplete(CustomEntityVersion customEntityVersion, CustomEntityVersionPageBlock newBlock)
{
_customEntityCache.Clear(customEntityVersion.CustomEntity.CustomEntityDefinitionCode, customEntityVersion.CustomEntityId);
return(_messageAggregator.PublishAsync(new CustomEntityVersionBlockAddedMessage()
{
CustomEntityId = customEntityVersion.CustomEntityId,
CustomEntityVersionPageBlockId = newBlock.CustomEntityVersionPageBlockId,
CustomEntityDefinitionCode = customEntityVersion.CustomEntity.CustomEntityDefinitionCode
}));
}
private IsCustomEntityUrlSlugUniqueQuery GetUniquenessQuery(CustomEntityVersion dbVersion, ICustomEntityDefinition definition)
{
var query = new IsCustomEntityUrlSlugUniqueQuery();
query.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
query.LocaleId = dbVersion.CustomEntity.LocaleId;
query.UrlSlug = SlugFormatter.ToSlug(dbVersion.Title);
query.CustomEntityId = dbVersion.CustomEntityId;
return(query);
}
/// <summary>
/// Maps an EF CustomEntityVersion record from the db into a CustomEntityVersionSummary
/// object. If the db record is null then null is returned.
/// </summary>
/// <param name="dbVersion">CustomEntityVersion record from the database.</param>
private CustomEntityVersionSummary MapVersion(CustomEntityVersion dbVersion)
{
var versionSummary = new CustomEntityVersionSummary()
{
CustomEntityVersionId = dbVersion.CustomEntityVersionId,
Title = dbVersion.Title,
WorkFlowStatus = (WorkFlowStatus)dbVersion.WorkFlowStatusId,
AuditData = _auditDataMapper.MapCreateAuditData(dbVersion)
};
return(versionSummary);
}
private static GetPageRoutingInfoByCustomEntityIdQuery GetPageRoutingQuery(CustomEntityVersion dbResult)
{
if (dbResult == null)
{
throw new ArgumentNullException(nameof(dbResult));
}
if (dbResult.CustomEntity == null)
{
throw new ArgumentNullException(nameof(dbResult.CustomEntity));
}
return(new GetPageRoutingInfoByCustomEntityIdQuery(dbResult.CustomEntityId));
}
private CustomEntityRenderSummary MapSingle(
CustomEntityVersion dbResult,
ICollection <PageRoutingInfo> allRoutings,
ActiveLocale locale
)
{
var entity = MapCore(dbResult);
entity.Locale = locale;
entity.PageUrls = MapPageRoutings(allRoutings, dbResult);
return(entity);
}
private CustomEntityRenderSummary MapSingle(
CustomEntityVersion dbResult,
IEnumerable <PageRoutingInfo> allRoutings,
ActiveLocale locale
)
{
var entity = Mapper.Map <CustomEntityRenderSummary>(dbResult);
entity.Locale = locale;
entity.Model = _customEntityDataModelMapper.Map(dbResult.CustomEntity.CustomEntityDefinitionCode, dbResult.SerializedData);
entity.DetailsPageUrls = MapPageRoutings(allRoutings, dbResult);
return(entity);
}
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);
}
/// <summary>
/// If the url slug is autogenerated, we need to update it only when the custom entity is published.
/// </summary>
private async Task UpdateUrlSlugIfRequired(CustomEntityVersion dbVersion, ICustomEntityDefinition definition)
{
if (!definition.AutoGenerateUrlSlug)
{
return;
}
var urlCommand = new UpdateCustomEntityUrlCommand()
{
CustomEntityId = dbVersion.CustomEntityId,
LocaleId = dbVersion.CustomEntity.LocaleId,
UrlSlug = SlugFormatter.ToSlug(dbVersion.Title)
};
await _commandExecutor.ExecuteAsync(urlCommand);
}
public async Task <CustomEntityRenderSummary> MapSummaryAsync(
CustomEntityVersion dbResult,
IExecutionContext executionContext
)
{
var routingQuery = GetPageRoutingQuery(dbResult);
var routing = await _queryExecutor.ExecuteAsync(routingQuery, executionContext);
ActiveLocale locale = null;
if (dbResult.CustomEntity.LocaleId.HasValue)
{
locale = await _queryExecutor.GetByIdAsync <ActiveLocale>(dbResult.CustomEntity.LocaleId.Value, executionContext);
}
return(MapSingle(dbResult, routing, locale));
}
private AddCustomEntityCommand MapCommand(
DuplicateCustomEntityCommand command,
CustomEntityVersion customEntityVersionToDuplicate
)
{
EntityNotFoundException.ThrowIfNull(customEntityVersionToDuplicate, command.CustomEntityToDuplicateId);
var addCustomEntityCommand = new AddCustomEntityCommand();
addCustomEntityCommand.Title = command.Title;
addCustomEntityCommand.LocaleId = command.LocaleId;
addCustomEntityCommand.UrlSlug = command.UrlSlug;
addCustomEntityCommand.CustomEntityDefinitionCode = customEntityVersionToDuplicate.CustomEntity.CustomEntityDefinitionCode;
addCustomEntityCommand.Model = _customEntityDataModelMapper.Map(addCustomEntityCommand.CustomEntityDefinitionCode, customEntityVersionToDuplicate.SerializedData);
return(addCustomEntityCommand);
}
private async Task <CustomEntityVersion> CreateDraftIfRequiredAsync(
UpdateCustomEntityDraftVersionCommand command,
CustomEntityVersion draft,
IExecutionContext executionContext
)
{
if (draft != null)
{
return(draft);
}
var addDraftCommand = new AddCustomEntityDraftVersionCommand();
addDraftCommand.CustomEntityId = command.CustomEntityId;
await _commandExecutor.ExecuteAsync(addDraftCommand, executionContext);
return(await GetDraftVersionAsync(command));
}
private async Task ValidateTitleAsync(CustomEntityVersion dbVersion, ICustomEntityDefinition definition, IExecutionContext executionContext)
{
if (!definition.ForceUrlSlugUniqueness || SlugFormatter.ToSlug(dbVersion.Title) == dbVersion.CustomEntity.UrlSlug)
{
return;
}
var query = GetUniquenessQuery(dbVersion, definition);
var isUnique = await _queryExecutor.ExecuteAsync(query, executionContext);
if (!isUnique)
{
var message = string.Format("Cannot publish because the {1} '{0}' is not unique (symbols and spaces are ignored in the uniqueness check)",
dbVersion.Title,
definition.GetTerms().GetOrDefault(CustomizableCustomEntityTermKeys.Title, "title").ToLower());
throw new UniqueConstraintViolationException(message, "Title", dbVersion.Title);
}
}
private CustomEntityRenderSummary MapCore(CustomEntityVersion dbResult)
{
var entity = new CustomEntityRenderSummary()
{
CreateDate = DbDateTimeMapper.AsUtc(dbResult.CreateDate),
CustomEntityDefinitionCode = dbResult.CustomEntity.CustomEntityDefinitionCode,
CustomEntityId = dbResult.CustomEntityId,
CustomEntityVersionId = dbResult.CustomEntityVersionId,
Ordering = dbResult.CustomEntity.Ordering,
Title = dbResult.Title,
UrlSlug = dbResult.CustomEntity.UrlSlug,
WorkFlowStatus = (WorkFlowStatus)dbResult.WorkFlowStatusId,
PublishDate = DbDateTimeMapper.AsUtc(dbResult.CustomEntity.PublishDate)
};
entity.PublishStatus = PublishStatusMapper.FromCode(dbResult.CustomEntity.PublishStatusCode);
entity.Model = _customEntityDataModelMapper.Map(dbResult.CustomEntity.CustomEntityDefinitionCode, dbResult.SerializedData);
return(entity);
}
private ICollection<string> MapPageRoutings(
ICollection<PageRoutingInfo> allRoutings,
CustomEntityVersion dbResult
)
{
if (allRoutings == null) return Array.Empty<string>();
var urls = new List<string>(allRoutings.Count());
foreach (var detailsRouting in allRoutings
.Where(r => r.CustomEntityRouteRule != null))
{
var detailsUrl = detailsRouting
.CustomEntityRouteRule
.MakeUrl(detailsRouting.PageRoute, detailsRouting.CustomEntityRoute);
urls.Add(detailsUrl);
}
return urls;
}
private CustomEntityRenderDetails MapCustomEntity(CustomEntityVersion dbResult, IExecutionContext executionContext)
{
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityReadPermission>(dbResult.CustomEntity.CustomEntityDefinitionCode, executionContext.UserContext);
var entity = new CustomEntityRenderDetails()
{
CreateDate = DbDateTimeMapper.AsUtc(dbResult.CreateDate),
CustomEntityDefinitionCode = dbResult.CustomEntity.CustomEntityDefinitionCode,
CustomEntityId = dbResult.CustomEntityId,
CustomEntityVersionId = dbResult.CustomEntityVersionId,
Ordering = dbResult.CustomEntity.Ordering,
Title = dbResult.Title,
UrlSlug = dbResult.CustomEntity.UrlSlug,
WorkFlowStatus = (WorkFlowStatus)dbResult.WorkFlowStatusId,
PublishDate = DbDateTimeMapper.AsUtc(dbResult.CustomEntity.PublishDate)
};
entity.PublishStatus = PublishStatusMapper.FromCode(dbResult.CustomEntity.PublishStatusCode);
entity.Model = _customEntityDataModelMapper.Map(dbResult.CustomEntity.CustomEntityDefinitionCode, dbResult.SerializedData);
return(entity);
}
private CustomEntity MapEntity(AddCustomEntityCommand command, CustomEntityDefinitionSummary definition, IExecutionContext executionContext)
{
// Create Page
var entity = new CustomEntity();
_entityAuditHelper.SetCreated(entity, executionContext);
entity.Locale = GetLocale(command.LocaleId);
entity.UrlSlug = command.UrlSlug;
entity.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
var version = new CustomEntityVersion();
version.Title = command.Title.Trim();
version.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.Model);
version.WorkFlowStatusId = command.Publish ? (int)WorkFlowStatus.Published : (int)WorkFlowStatus.Draft;
_entityAuditHelper.SetCreated(version, executionContext);
entity.CustomEntityVersions.Add(version);
return(entity);
}
private async Task<CustomEntityRenderDetails> MapCustomEntityAsync(CustomEntityVersion dbResult)
{
await _permissionValidationService.EnforceCustomEntityPermissionAsync<CustomEntityReadPermission>(dbResult.CustomEntity.CustomEntityDefinitionCode);
var entity = new CustomEntityRenderDetails()
{
CreateDate = DbDateTimeMapper.AsUtc(dbResult.CreateDate),
CustomEntityDefinitionCode = dbResult.CustomEntity.CustomEntityDefinitionCode,
CustomEntityId = dbResult.CustomEntityId,
CustomEntityVersionId = dbResult.CustomEntityVersionId,
Ordering = dbResult.CustomEntity.Ordering,
Title = dbResult.Title,
UrlSlug = dbResult.CustomEntity.UrlSlug,
WorkFlowStatus = (WorkFlowStatus)dbResult.WorkFlowStatusId,
PublishDate = DbDateTimeMapper.AsUtc(dbResult.CustomEntity.PublishDate)
};
entity.PublishStatus = PublishStatusMapper.FromCode(dbResult.CustomEntity.PublishStatusCode);
entity.Model = _customEntityDataModelMapper.Map(dbResult.CustomEntity.CustomEntityDefinitionCode, dbResult.SerializedData);
return entity;
}
private IEnumerable <string> MapPageRoutings(
IEnumerable <PageRoutingInfo> allRoutings,
CustomEntityVersion dbResult)
{
if (allRoutings == null)
{
return(Enumerable.Empty <string>());
}
var urls = new List <string>(allRoutings.Count());
foreach (var detailsRouting in allRoutings
.Where(r => r.CustomEntityRouteRule != null))
{
var detailsUrl = detailsRouting
.CustomEntityRouteRule
.MakeUrl(detailsRouting.PageRoute, detailsRouting.CustomEntityRoute);
urls.Add(detailsUrl);
}
return(urls);
}
/// <summary>
/// Maps an EF CustomEntityVersion record from the db into a CustomEntityRenderSummary
/// object. If the db record is null then null is returned.
/// </summary>
/// <param name="dbResult">CustomEntityVersion record from the database.</param>
/// <param name="executionContext">Context to run any sub queries under.</param>
public async Task <CustomEntityRenderSummary> MapAsync(
CustomEntityVersion dbResult,
IExecutionContext executionContext
)
{
if (dbResult == null)
{
return(null);
}
var routingQuery = GetPageRoutingQuery(dbResult);
var routing = await _queryExecutor.ExecuteAsync(routingQuery, executionContext);
ActiveLocale locale = null;
if (dbResult.CustomEntity.LocaleId.HasValue)
{
var getLocaleQuery = new GetActiveLocaleByIdQuery(dbResult.CustomEntity.LocaleId.Value);
locale = await _queryExecutor.ExecuteAsync(getLocaleQuery, executionContext);
}
return(MapSingle(dbResult, routing, locale));
}
private async Task MapPages(CustomEntityVersion dbVersion, CustomEntityDetails entity, IExecutionContext executionContext)
{
var pages = new List <CustomEntityPage>();
entity.LatestVersion.Pages = pages;
var routingsQuery = new GetPageRoutingInfoByCustomEntityIdQuery(dbVersion.CustomEntityId);
var routings = (await _queryExecutor.ExecuteAsync(routingsQuery, executionContext))
.Where(r => r.CustomEntityRouteRule != null);
if (!routings.Any())
{
return;
}
// Map templates
var pageTemplateIds = routings
.Select(r => new
{
PageId = r.PageRoute.PageId,
VersionRoute = r.PageRoute.Versions.GetVersionRouting(PublishStatusQuery.Latest)
})
.Where(r => r.VersionRoute != null && r.VersionRoute.HasCustomEntityRegions)
.ToDictionary(k => k.PageId, v => v.VersionRoute.PageTemplateId);
var allTemplateIds = pageTemplateIds
.Select(r => r.Value)
.ToArray();
var allTemplateRegions = await _dbContext
.PageTemplateRegions
.AsNoTracking()
.Where(s => allTemplateIds.Contains(s.PageTemplateId) && s.IsCustomEntityRegion)
.ToListAsync();
var allPageBlockTypes = await _queryExecutor.ExecuteAsync(new GetAllPageBlockTypeSummariesQuery(), executionContext);
foreach (var routing in routings)
{
var page = new CustomEntityPage();
pages.Add(page);
page.FullPath = routing.CustomEntityRouteRule.MakeUrl(routing.PageRoute, routing.CustomEntityRoute);
page.PageRoute = routing.PageRoute;
// Map Regions
var templateId = pageTemplateIds.GetOrDefault(routing.PageRoute.PageId);
page.Regions = allTemplateRegions
.Where(s => s.PageTemplateId == templateId)
.OrderBy(s => s.UpdateDate)
.Select(s => new CustomEntityPageRegionDetails()
{
Name = s.Name,
PageTemplateRegionId = s.PageTemplateRegionId
})
.ToList();
// Map Blocks
foreach (var region in page.Regions)
{
region.Blocks = dbVersion
.CustomEntityVersionPageBlocks
.AsQueryable()
.FilterActive()
.Where(m => m.PageTemplateRegionId == region.PageTemplateRegionId)
.OrderBy(m => m.Ordering)
.Select(m => MapBlock(m, allPageBlockTypes))
.ToArray();
}
}
// Map default full path
entity.FullPath = pages
.OrderByDescending(p => p.PageRoute.Locale == null)
.Select(p => p.FullPath)
.First();
}
private Task OnUpdateDraftComplete(UpdateCustomEntityDraftVersionCommand command, CustomEntityVersion draft)
{
_customEntityCache.Clear(command.CustomEntityDefinitionCode, command.CustomEntityId);
return(_messageAggregator.PublishAsync(new CustomEntityDraftVersionUpdatedMessage()
{
CustomEntityId = command.CustomEntityId,
CustomEntityDefinitionCode = command.CustomEntityDefinitionCode,
CustomEntityVersionId = draft.CustomEntityVersionId
}));
}
