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);
}
public async Task SetCacheAsync(IEditablePageViewModel vm, PageActionRoutingState state)
{
var siteViewerMode = state.VisualEditorMode;
var publishStatusQuery = state.VisualEditorMode.ToPublishStatusQuery();
var pageVersions = state.PageRoutingInfo.PageRoute.Versions;
// Force a viewer mode
if (siteViewerMode == VisualEditorMode.Any)
{
var version = state.PageRoutingInfo.GetVersionRoute(
state.InputParameters.IsEditingCustomEntity,
state.VisualEditorMode.ToPublishStatusQuery(),
state.InputParameters.VersionId);
switch (version.WorkFlowStatus)
{
case WorkFlowStatus.Draft:
siteViewerMode = VisualEditorMode.Draft;
break;
case WorkFlowStatus.Published:
siteViewerMode = VisualEditorMode.Live;
break;
default:
throw new InvalidOperationException("WorkFlowStatus." + version.WorkFlowStatus + " is not valid for VisualEditorMode.Any");
}
}
var pageResponseData = new PageResponseData();
pageResponseData.Page = vm;
pageResponseData.VisualEditorMode = siteViewerMode;
pageResponseData.PageRoutingInfo = state.PageRoutingInfo;
pageResponseData.HasDraftVersion = state.PageRoutingInfo.GetVersionRoute(state.InputParameters.IsEditingCustomEntity, PublishStatusQuery.Draft, null) != null;
pageResponseData.Version = state.PageRoutingInfo.GetVersionRoute(state.InputParameters.IsEditingCustomEntity, publishStatusQuery, state.InputParameters.VersionId);
pageResponseData.CofoundryAdminUserContext = state.CofoundryAdminUserContext;
var customEntityDefinitionCode = state.PageRoutingInfo.PageRoute.CustomEntityDefinitionCode;
if (!string.IsNullOrEmpty(customEntityDefinitionCode))
{
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(customEntityDefinitionCode);
pageResponseData.CustomEntityDefinition = await _queryExecutor.ExecuteAsync(definitionQuery);
}
if (state.InputParameters.IsEditingCustomEntity)
{
pageResponseData.PageVersion = pageVersions.GetVersionRouting(PublishStatusQuery.Latest);
}
else
{
pageResponseData.PageVersion = pageVersions.GetVersionRouting(publishStatusQuery, state.InputParameters.VersionId);
}
_pageRenderDataCache.Set(pageResponseData);
}
private async Task <CustomEntityDefinitionSummary> GetDefinitionAsync(
IsCustomEntityUrlSlugUniqueQuery query,
IExecutionContext executionContext
)
{
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(query.CustomEntityDefinitionCode);
var definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
EntityNotFoundException.ThrowIfNull(definition, query.CustomEntityDefinitionCode);
return(definition);
}
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 async Task <CustomEntityDataModelSchema> ExecuteAsync(GetCustomEntityDataModelSchemaDetailsByDefinitionCodeQuery query, IExecutionContext executionContext)
{
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(query.CustomEntityDefinitionCode);
var definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
if (definition == null)
{
return(null);
}
var result = new CustomEntityDataModelSchema();
result.CustomEntityDefinitionCode = definition.CustomEntityDefinitionCode;
_dynamicDataModelTypeMapper.Map(result, definition.DataModelType);
return(result);
}
public async Task ExecuteAsync(AddCustomEntityCommand command, IExecutionContext executionContext)
{
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(command.CustomEntityDefinitionCode);
var definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
EntityNotFoundException.ThrowIfNull(definition, command.CustomEntityDefinitionCode);
await _commandExecutor.ExecuteAsync(new EnsureCustomEntityDefinitionExistsCommand(definition.CustomEntityDefinitionCode), executionContext);
// Custom Validation
ValidateCommand(command, definition);
await ValidateIsUniqueAsync(command, definition, executionContext);
var entity = MapEntity(command, definition, executionContext);
await SetOrdering(entity, definition);
_dbContext.CustomEntities.Add(entity);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _dbContext.SaveChangesAsync();
var dependencyCommand = new UpdateUnstructuredDataDependenciesCommand(
CustomEntityVersionEntityDefinition.DefinitionCode,
entity.CustomEntityVersions.First().CustomEntityVersionId,
command.Model);
await _commandExecutor.ExecuteAsync(dependencyCommand, executionContext);
await _customEntityStoredProcedures.UpdatePublishStatusQueryLookupAsync(entity.CustomEntityId);
scope.QueueCompletionTask(() => OnTransactionComplete(command, entity));
await scope.CompleteAsync();
}
// Set Ouput
command.OutputCustomEntityId = entity.CustomEntityId;
}
public async Task ExecuteAsync(UpdateCustomEntityUrlCommand command, IExecutionContext executionContext)
{
var entity = await _dbContext
.CustomEntities
.Where(e => e.CustomEntityId == command.CustomEntityId)
.SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(entity, command.CustomEntityId);
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityUpdateUrlPermission>(entity.CustomEntityDefinitionCode, executionContext.UserContext);
var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(entity.CustomEntityDefinitionCode);
var definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext);
EntityNotFoundException.ThrowIfNull(definition, entity.CustomEntityDefinitionCode);
await ValidateIsUniqueAsync(command, definition, executionContext);
Map(command, entity, definition);
await _dbContext.SaveChangesAsync();
await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(entity));
}
public IDomainRepositoryQueryContext <CustomEntityDefinitionSummary> AsSummary()
{
var query = new GetCustomEntityDefinitionSummaryByCodeQuery(_customEntityDefinitionCode);
return(DomainRepositoryQueryContextFactory.Create(query, ExtendableContentRepository));
}
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);
}
