public async Task ExecuteAsync(DeleteCustomEntityCommand command, IExecutionContext executionContext) { var customEntity = await _dbContext .CustomEntities .SingleOrDefaultAsync(p => p.CustomEntityId == command.CustomEntityId); if (customEntity != null) { await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityDeletePermission>(customEntity.CustomEntityDefinitionCode); using (var scope = _transactionScopeFactory.Create(_dbContext)) { await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(customEntity.CustomEntityDefinitionCode, customEntity.CustomEntityId), executionContext); _dbContext.CustomEntities.Remove(customEntity); await _dbContext.SaveChangesAsync(); await _customEntityStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.CustomEntityId); scope.Complete(); } _customEntityCache.Clear(customEntity.CustomEntityDefinitionCode, command.CustomEntityId); await _messageAggregator.PublishAsync(new CustomEntityDeletedMessage() { CustomEntityId = command.CustomEntityId, CustomEntityDefinitionCode = customEntity.CustomEntityDefinitionCode }); } }
public async Task <UpdateCustomEntityDraftVersionCommand> ExecuteAsync(GetUpdateCommandByIdQuery <UpdateCustomEntityDraftVersionCommand> query, IExecutionContext executionContext) { var dbResult = await _dbContext .CustomEntityVersions .Include(v => v.CustomEntity) .AsNoTracking() .FilterByActive() .FilterByCustomEntityId(query.Id) .Where(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft) .SingleOrDefaultAsync(); if (dbResult == null) { return(null); } await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityReadPermission>(dbResult.CustomEntity.CustomEntityDefinitionCode); 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 ExecuteAsync(UpdateCustomEntityUrlCommand command, IExecutionContext executionContext) { var entity = await _dbContext .CustomEntities .Where(e => e.CustomEntityId == command.CustomEntityId) .SingleOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(entity, command.CustomEntityId); await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityUpdateUrlPermission>(entity.CustomEntityDefinitionCode); var definitionQuery = new GetCustomEntityDefinitionSummaryByCodeQuery(entity.CustomEntityDefinitionCode); var definition = await _queryExecutor.ExecuteAsync(definitionQuery, executionContext); EntityNotFoundException.ThrowIfNull(definition, entity.CustomEntityDefinitionCode); await ValidateIsUnique(command, definition); Map(command, entity, definition); await _dbContext.SaveChangesAsync(); _customEntityCache.Clear(entity.CustomEntityDefinitionCode, command.CustomEntityId); await _messageAggregator.PublishAsync(new CustomEntityUrlChangedMessage() { CustomEntityId = command.CustomEntityId, CustomEntityDefinitionCode = entity.CustomEntityDefinitionCode, HasPublishedVersionChanged = entity.PublishStatusCode == PublishStatusCode.Published }); }
public async Task <CustomEntityDetails> ExecuteAsync(GetCustomEntityDetailsByIdQuery query, IExecutionContext executionContext) { var customEntityVersion = await Query(query.CustomEntityId).FirstOrDefaultAsync(); await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityReadPermission>(customEntityVersion.CustomEntity.CustomEntityDefinitionCode); return(await MapAsync(query, customEntityVersion, executionContext)); }
public async Task ExecuteAsync(PublishCustomEntityCommand command, IExecutionContext executionContext) { // Prefer draft, but update published entity if no draft (only one draft permitted) var version = await _dbContext .CustomEntityVersions .Include(v => v.CustomEntity) .Where(v => v.CustomEntityId == command.CustomEntityId && (v.WorkFlowStatusId == (int)WorkFlowStatus.Draft || v.WorkFlowStatusId == (int)WorkFlowStatus.Published)) .OrderByDescending(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft) .ThenByDescending(v => v.CreateDate) .FirstOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(version, command.CustomEntityId); var definition = _customEntityDefinitionRepository.GetByCode(version.CustomEntity.CustomEntityDefinitionCode); EntityNotFoundException.ThrowIfNull(definition, version.CustomEntity.CustomEntityDefinitionCode); await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityPublishPermission>(definition.CustomEntityDefinitionCode); UpdatePublishDate(command, executionContext, version); if (version.WorkFlowStatusId == (int)WorkFlowStatus.Published) { // only thing we can do with a published version is update the date await _dbContext.SaveChangesAsync(); } else { await ValidateTitle(version, definition); using (var scope = _transactionScopeFactory.Create(_dbContext)) { await UpdateUrlSlugIfRequired(version, definition); version.WorkFlowStatusId = (int)WorkFlowStatus.Published; version.CustomEntity.PublishStatusCode = PublishStatusCode.Published; await _dbContext.SaveChangesAsync(); await _customEntityStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.CustomEntityId); scope.Complete(); } } _customEntityCache.Clear(version.CustomEntity.CustomEntityDefinitionCode, command.CustomEntityId); await _messageAggregator.PublishAsync(new CustomEntityPublishedMessage() { CustomEntityId = command.CustomEntityId, CustomEntityDefinitionCode = version.CustomEntity.CustomEntityDefinitionCode }); }
public async Task <CustomEntityRenderSummary> ExecuteAsync(GetCustomEntityRenderSummaryByIdQuery query, IExecutionContext executionContext) { var dbResult = await QueryAsync(query, executionContext); if (dbResult == null) { return(null); } await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityReadPermission>(dbResult.CustomEntity.CustomEntityDefinitionCode); var result = await _customEntityRenderSummaryMapper.MapAsync(dbResult, executionContext); return(result); }
public async Task ExecuteAsync(UpdateCustomEntityVersionPageBlockCommand command, IExecutionContext executionContext) { var dbBlock = await _dbContext .CustomEntityVersionPageBlocks .Include(m => m.PageBlockTypeTemplate) .Include(m => m.PageBlockType) .Include(m => m.CustomEntityVersion) .ThenInclude(v => v.CustomEntity) .Where(l => l.CustomEntityVersionPageBlockId == command.CustomEntityVersionPageBlockId) .SingleOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(dbBlock, command.CustomEntityVersionPageBlockId); await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityUpdatePermission>(dbBlock.CustomEntityVersion.CustomEntity.CustomEntityDefinitionCode); if (dbBlock.CustomEntityVersion.WorkFlowStatusId != (int)WorkFlowStatus.Draft) { throw new NotPermittedException("Page blocks cannot be updated unless the entity is in draft status"); } using (var scope = _transactionScopeFactory.Create(_dbContext)) { await _pageBlockCommandHelper.UpdateModelAsync(command, dbBlock); await _dbContext.SaveChangesAsync(); var dependencyCommand = new UpdateUnstructuredDataDependenciesCommand( CustomEntityVersionPageBlockEntityDefinition.DefinitionCode, dbBlock.CustomEntityVersionPageBlockId, command.DataModel); await _commandExecutor.ExecuteAsync(dependencyCommand); scope.Complete(); } _customEntityCache.Clear(dbBlock.CustomEntityVersion.CustomEntity.CustomEntityDefinitionCode, dbBlock.CustomEntityVersion.CustomEntity.CustomEntityId); await _messageAggregator.PublishAsync(new CustomEntityVersionBlockUpdatedMessage() { CustomEntityId = dbBlock.CustomEntityVersion.CustomEntityId, CustomEntityDefinitionCode = dbBlock.CustomEntityVersion.CustomEntity.CustomEntityDefinitionCode, CustomEntityVersionBlockId = dbBlock.CustomEntityVersionPageBlockId }); }
public async Task ExecuteAsync(DeleteCustomEntityVersionPageBlockCommand command, IExecutionContext executionContext) { var dbResult = await _dbContext .CustomEntityVersionPageBlocks .Where(m => m.CustomEntityVersionPageBlockId == command.CustomEntityVersionPageBlockId) .Select(m => new { Block = m, CustomEntityId = m.CustomEntityVersion.CustomEntityId, CustomEntityDefinitionCode = m.CustomEntityVersion.CustomEntity.CustomEntityDefinitionCode, WorkFlowStatusId = m.CustomEntityVersion.WorkFlowStatusId }) .SingleOrDefaultAsync(); if (dbResult != null) { await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityUpdatePermission>(dbResult.CustomEntityDefinitionCode); if (dbResult.WorkFlowStatusId != (int)WorkFlowStatus.Draft) { throw new NotPermittedException("Page blocks cannot be deleted unless the entity is in draft status"); } var customEntityVersionBlockId = dbResult.Block.CustomEntityVersionPageBlockId; using (var scope = _transactionScopeFactory.Create(_dbContext)) { await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(CustomEntityVersionPageBlockEntityDefinition.DefinitionCode, dbResult.Block.CustomEntityVersionPageBlockId)); _dbContext.CustomEntityVersionPageBlocks.Remove(dbResult.Block); await _dbContext.SaveChangesAsync(); scope.Complete(); } _customEntityCache.Clear(dbResult.CustomEntityDefinitionCode, dbResult.CustomEntityId); await _messageAggregator.PublishAsync(new CustomEntityVersionBlockDeletedMessage() { CustomEntityId = dbResult.CustomEntityId, CustomEntityDefinitionCode = dbResult.CustomEntityDefinitionCode, CustomEntityVersionId = customEntityVersionBlockId }); } }
public async Task ExecuteAsync(UpdateCustomEntityOrderingPositionCommand command, IExecutionContext executionContext) { var customEntity = await _dbContext .CustomEntities .AsNoTracking() .FilterByCustomEntityId(command.CustomEntityId) .FirstOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(customEntity, command.CustomEntityId); await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityUpdatePermission>(customEntity.CustomEntityDefinitionCode); if (!command.Position.HasValue) { // The new position might be null (which means no ordering allocated) await SetOrderingNull(customEntity); } else { var orderedIds = await _dbContext .CustomEntities .Where(e => e.CustomEntityDefinitionCode == customEntity.CustomEntityDefinitionCode && e.CustomEntityId != command.CustomEntityId && e.Ordering.HasValue) .OrderBy(e => e.Ordering) .Select(e => e.CustomEntityId) .ToListAsync(); var newPos = orderedIds.Count <= command.Position ? command.Position : null; if (!newPos.HasValue) { await SetOrderingNull(customEntity); } else { orderedIds.Insert(newPos.Value, command.CustomEntityId); var reorderCommand = new ReOrderCustomEntitiesCommand(); reorderCommand.CustomEntityDefinitionCode = customEntity.CustomEntityDefinitionCode; reorderCommand.OrderedCustomEntityIds = orderedIds.ToArray(); } } }
public async Task <ICollection <CustomEntityVersionSummary> > ExecuteAsync(GetCustomEntityVersionSummariesByCustomEntityIdQuery query, IExecutionContext executionContext) { var definitionCode = await _dbContext .CustomEntities .AsNoTracking() .Where(c => c.CustomEntityId == query.CustomEntityId) .Select(c => c.CustomEntityDefinitionCode) .FirstOrDefaultAsync(); if (definitionCode == null) { return(null); } await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityReadPermission>(definitionCode); var dbVersions = await Query(query.CustomEntityId).ToListAsync(); var versions = _customEntityVersionSummaryMapper.MapVersions(query.CustomEntityId, dbVersions); return(versions); }
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 async Task <CustomEntityVersionPageBlockRenderDetails> MapAsync( CustomEntityVersionPageBlock versionBlock, string blockTypeFileName, string customEntityDefinitionCode, PublishStatusQuery publishStatus, IExecutionContext executionContext ) { await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityReadPermission>(customEntityDefinitionCode); var blockTypeQuery = new GetPageBlockTypeSummaryByIdQuery(versionBlock.PageBlockTypeId); var blockType = await _queryExecutor.ExecuteAsync(blockTypeQuery, executionContext); EntityNotFoundException.ThrowIfNull(blockType, versionBlock.PageBlockTypeId); var result = new CustomEntityVersionPageBlockRenderDetails(); result.CustomEntityVersionPageBlockId = versionBlock.CustomEntityVersionPageBlockId; result.BlockType = blockType; result.DisplayModel = await _pageVersionBlockModelMapper.MapDisplayModelAsync(blockTypeFileName, versionBlock, publishStatus); return(result); }
public async Task ExecuteAsync(DeleteCustomEntityDraftVersionCommand command, IExecutionContext executionContext) { var draft = await _dbContext .CustomEntityVersions .Include(v => v.CustomEntity) .SingleOrDefaultAsync(v => v.CustomEntityId == command.CustomEntityId && v.WorkFlowStatusId == (int)WorkFlowStatus.Draft); if (draft != null) { await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityUpdatePermission>(draft.CustomEntity.CustomEntityDefinitionCode); var definitionCode = draft.CustomEntity.CustomEntityDefinitionCode; var versionId = draft.CustomEntityVersionId; using (var scope = _transactionScopeFactory.Create(_dbContext)) { await _commandExecutor.ExecuteAsync(new DeleteUnstructuredDataDependenciesCommand(CustomEntityVersionEntityDefinition.DefinitionCode, draft.CustomEntityVersionId)); _dbContext.CustomEntityVersions.Remove(draft); await _dbContext.SaveChangesAsync(); await _customEntityStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.CustomEntityId); scope.Complete(); } _customEntityCache.Clear(definitionCode, command.CustomEntityId); await _messageAggregator.PublishAsync(new CustomEntityDraftVersionDeletedMessage() { CustomEntityId = command.CustomEntityId, CustomEntityDefinitionCode = definitionCode, CustomEntityVersionId = versionId }); } }
public async Task <UpdateCustomEntityVersionPageBlockCommand> ExecuteAsync(GetUpdateCommandByIdQuery <UpdateCustomEntityVersionPageBlockCommand> query, IExecutionContext executionContext) { var dbResult = await _dbContext .CustomEntityVersionPageBlocks .AsNoTracking() .Where(b => b.CustomEntityVersionPageBlockId == query.Id) .Select(b => new { PageBlock = b, PageBlockTypeFileName = b.PageBlockType.FileName, CustomEntityDefinitionCode = b.CustomEntityVersion.CustomEntity.CustomEntityDefinitionCode }) .SingleOrDefaultAsync(); if (dbResult == null) { return(null); } await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityReadPermission>(dbResult.CustomEntityDefinitionCode); var result = Map(dbResult.PageBlock, dbResult.PageBlockTypeFileName); return(result); }
public async Task ExecuteAsync(AddCustomEntityVersionPageBlockCommand command, IExecutionContext executionContext) { var customEntityVersion = _dbContext .CustomEntityVersions .Include(s => s.CustomEntityVersionPageBlocks) .Include(s => s.CustomEntity) .FirstOrDefault(v => v.CustomEntityVersionId == command.CustomEntityVersionId); EntityNotFoundException.ThrowIfNull(customEntityVersion, command.CustomEntityVersionId); await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityUpdatePermission>(customEntityVersion.CustomEntity.CustomEntityDefinitionCode); if (customEntityVersion.WorkFlowStatusId != (int)WorkFlowStatus.Draft) { throw new NotPermittedException("Page blocks cannot be deleted unless the entity is in draft status"); } var templateRegion = await _dbContext .PageTemplateRegions .FirstOrDefaultAsync(l => l.PageTemplateRegionId == command.PageTemplateRegionId); EntityNotFoundException.ThrowIfNull(templateRegion, command.PageTemplateRegionId); var customEntityVersionBlocks = customEntityVersion .CustomEntityVersionPageBlocks .Where(m => m.PageTemplateRegionId == templateRegion.PageTemplateRegionId); CustomEntityVersionPageBlock adjacentItem = null; if (command.AdjacentVersionBlockId.HasValue) { adjacentItem = customEntityVersionBlocks .SingleOrDefault(m => m.CustomEntityVersionPageBlockId == command.AdjacentVersionBlockId); EntityNotFoundException.ThrowIfNull(adjacentItem, command.AdjacentVersionBlockId); } var newBlock = new CustomEntityVersionPageBlock(); newBlock.PageTemplateRegion = templateRegion; await _pageBlockCommandHelper.UpdateModelAsync(command, newBlock); newBlock.CustomEntityVersion = customEntityVersion; _entityOrderableHelper.SetOrderingForInsert(customEntityVersionBlocks, newBlock, command.InsertMode, adjacentItem); _dbContext.CustomEntityVersionPageBlocks.Add(newBlock); using (var scope = _transactionScopeFactory.Create(_dbContext)) { await _dbContext.SaveChangesAsync(); var dependencyCommand = new UpdateUnstructuredDataDependenciesCommand( CustomEntityVersionPageBlockEntityDefinition.DefinitionCode, newBlock.CustomEntityVersionPageBlockId, command.DataModel); await _commandExecutor.ExecuteAsync(dependencyCommand); scope.Complete(); } _customEntityCache.Clear(customEntityVersion.CustomEntity.CustomEntityDefinitionCode, customEntityVersion.CustomEntityId); command.OutputCustomEntityVersionPageBlockId = newBlock.CustomEntityVersionPageBlockId; await _messageAggregator.PublishAsync(new CustomEntityVersionBlockAddedMessage() { CustomEntityId = customEntityVersion.CustomEntityId, CustomEntityVersionPageBlockId = newBlock.CustomEntityVersionPageBlockId, CustomEntityDefinitionCode = customEntityVersion.CustomEntity.CustomEntityDefinitionCode }); }
public async Task ExecuteAsync(MoveCustomEntityVersionPageBlockCommand command, IExecutionContext executionContext) { var dbResult = await _dbContext .CustomEntityVersionPageBlocks .Where(b => b.CustomEntityVersionPageBlockId == command.CustomEntityVersionPageBlockId) .Select(b => new { Block = b, CustomEntityId = b.CustomEntityVersion.CustomEntityId, CustomEntityDefinitionCode = b.CustomEntityVersion.CustomEntity.CustomEntityDefinitionCode, WorkFlowStatusId = b.CustomEntityVersion.WorkFlowStatusId }) .SingleOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(dbResult, command.CustomEntityVersionPageBlockId); await _permissionValidationService.EnforceCustomEntityPermissionAsync <CustomEntityUpdatePermission>(dbResult.CustomEntityDefinitionCode); if (dbResult.WorkFlowStatusId != (int)WorkFlowStatus.Draft) { throw new NotPermittedException("Page blocks cannot be moved unless the entity is in draft status"); } var block = dbResult.Block; var blockToSwapWithQuery = _dbContext .CustomEntityVersionPageBlocks .Where(p => p.PageTemplateRegionId == block.PageTemplateRegionId && p.CustomEntityVersionId == block.CustomEntityVersionId); CustomEntityVersionPageBlock blockToSwapWith; switch (command.Direction) { case OrderedItemMoveDirection.Up: blockToSwapWith = await blockToSwapWithQuery .Where(p => p.Ordering < block.Ordering) .OrderByDescending(p => p.Ordering) .FirstOrDefaultAsync(); break; case OrderedItemMoveDirection.Down: blockToSwapWith = await blockToSwapWithQuery .Where(p => p.Ordering > block.Ordering) .OrderBy(p => p.Ordering) .FirstOrDefaultAsync(); break; default: throw new InvalidOperationException("OrderedItemMoveDirection not recognised: " + command.Direction); } if (blockToSwapWith == null) { return; } int oldOrdering = block.Ordering; block.Ordering = blockToSwapWith.Ordering; blockToSwapWith.Ordering = oldOrdering; await _dbContext.SaveChangesAsync(); _customEntityCache.Clear(dbResult.CustomEntityDefinitionCode, dbResult.CustomEntityId); await _messageAggregator.PublishAsync(new CustomEntityVersionBlockMovedMessage() { CustomEntityId = dbResult.CustomEntityId, CustomEntityDefinitionCode = dbResult.CustomEntityDefinitionCode, CustomEntityVersionBlockId = dbResult.Block.CustomEntityVersionPageBlockId }); }