public async Task ExecuteAsync(UpdatePageUrlCommand command, IExecutionContext executionContext) { Normalize(command); var page = await _dbContext .Pages .Include(p => p.Locale) .Include(p => p.PageDirectory) .FilterActive() .FilterById(command.PageId) .SingleOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(page, command.PageId); await ValidateIsPageUniqueAsync(command, page, executionContext); var originalPageRoute = await _queryExecutor.ExecuteAsync(new GetPageRouteByIdQuery(page.PageId)); EntityNotFoundException.ThrowIfNull(originalPageRoute, page.PageId); await MapPageAsync(command, executionContext, page); var isPublished = page.PublishStatusCode == PublishStatusCode.Published; await _dbContext.SaveChangesAsync(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(originalPageRoute, isPublished)); }
public async Task ExecuteAsync(DeletePageDirectoryCommand command, IExecutionContext executionContext) { var pageDirectory = await _dbContext .PageDirectories .SingleOrDefaultAsync(d => d.PageDirectoryId == command.PageDirectoryId); if (pageDirectory == null) { return; } ValidateNotRootDirectory(pageDirectory); var directoriesToDelete = await GetDirectoryIdsToDeleteAsync(command); await ValidateDependencies(PageDirectoryEntityDefinition.DefinitionCode, directoriesToDelete.Keys, executionContext); var pagesToDelete = await GetPageIdsToDeleteAndValidatePermissionAsync(directoriesToDelete.Keys, executionContext); await ValidateDependencies(PageEntityDefinition.DefinitionCode, pagesToDelete.Keys, executionContext); _dbContext.PageDirectories.Remove(pageDirectory); await _dbContext.SaveChangesAsync(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(directoriesToDelete.Values, pagesToDelete.Values)); }
public async Task ExecuteAsync(UpdatePageCommand command, IExecutionContext executionContext) { var page = await GetPageAsync(command.PageId); MapPage(command, executionContext, page); await _dbContext.SaveChangesAsync(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(page)); }
public async Task ExecuteAsync(UpdatePageCommand command, IExecutionContext executionContext) { var page = await GetPageById(command.PageId).SingleOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(page, command.PageId); MapPage(command, executionContext, page); await _dbContext.SaveChangesAsync(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(page)); }
public async Task ExecuteAsync(AddPageDraftVersionCommand command, IExecutionContext executionContext) { var newVersionId = await _pageStoredProcedures.AddDraftAsync( command.PageId, command.CopyFromPageVersionId, executionContext.ExecutionDate, executionContext.UserContext.UserId.Value); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(command, newVersionId)); // Set Ouput command.OutputPageVersionId = newVersionId; }
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); _permissionValidationService.EnforceCustomEntityPermission <CustomEntityPublishPermission>(definition.CustomEntityDefinitionCode, executionContext.UserContext); UpdatePublishDate(command, executionContext, version); if (version.WorkFlowStatusId == (int)WorkFlowStatus.Published && version.CustomEntity.PublishStatusCode == PublishStatusCode.Published) { // only thing we can do with a published version is update the date await _dbContext.SaveChangesAsync(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(version)); } else { await ValidateTitleAsync(version, definition, executionContext); using (var scope = _transactionScopeFactory.Create(_dbContext)) { await UpdateUrlSlugIfRequiredAsync(version, definition, executionContext); version.WorkFlowStatusId = (int)WorkFlowStatus.Published; version.CustomEntity.PublishStatusCode = PublishStatusCode.Published; await _dbContext.SaveChangesAsync(); await _customEntityStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.CustomEntityId); scope.QueueCompletionTask(() => OnTransactionComplete(version)); await scope.CompleteAsync(); } } }
public async Task ExecuteAsync(AddPageDraftVersionCommand command, IExecutionContext executionContext) { int newVersionId; try { newVersionId = await _pageStoredProcedures.AddDraftAsync( command.PageId, command.CopyFromPageVersionId, executionContext.ExecutionDate, executionContext.UserContext.UserId.Value); } catch (StoredProcedureExecutionException ex) when(ex.ErrorNumber == StoredProcedureErrorNumbers.Page_AddDraft.DraftAlreadyExists) { throw ValidationErrorException.CreateWithProperties("A draft cannot be created because this page already has one.", nameof(command.PageId)); } await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(command, newVersionId)); command.OutputPageVersionId = newVersionId; }
public async Task ExecuteAsync(AddUserCommand command, IExecutionContext executionContext) { var userArea = _userAreaRepository.GetRequiredByCode(command.UserAreaCode); var dbUserArea = await GetUserAreaAsync(userArea); var role = await GetAndValidateRoleAsync(command, executionContext); var user = new User() { FirstName = command.FirstName?.Trim(), LastName = command.LastName?.Trim(), RequirePasswordChange = command.RequirePasswordChange, LastPasswordChangeDate = executionContext.ExecutionDate, AccountVerifiedDate = command.IsAccountVerified ? executionContext.ExecutionDate : (DateTime?)null, CreateDate = executionContext.ExecutionDate, Role = role, UserArea = dbUserArea, CreatorId = executionContext.UserContext.UserId, SecurityStamp = _securityStampGenerator.Generate() }; if (!command.IsActive) { user.DeactivatedDate = executionContext.ExecutionDate; } await _userUpdateCommandHelper.UpdateEmailAndUsernameAsync(command.Email, command.Username, user, executionContext); await ValidatePasswordAsync(userArea, user, command, executionContext); SetPassword(user, command, userArea); SetDisplayName(command, user); _dbContext.Users.Add(user); await _dbContext.SaveChangesAsync(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(userArea, user)); command.OutputUserId = user.UserId; }
public async Task ExecuteAsync(PublishPageCommand command, IExecutionContext executionContext) { var version = await _dbContext .PageVersions .Include(p => p.Page) .FilterActive() .FilterByPageId(command.PageId) .OrderByLatest() .FirstOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(version, command.PageId); UpdatePublishDate(command, executionContext, version); if (version.WorkFlowStatusId == (int)WorkFlowStatus.Published && version.Page.PublishStatusCode == PublishStatusCode.Published) { // only thing we can do with a published version is update the date await _dbContext.SaveChangesAsync(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(command)); } else { version.WorkFlowStatusId = (int)WorkFlowStatus.Published; version.Page.PublishStatusCode = PublishStatusCode.Published; using (var scope = _transactionScopeFactory.Create(_dbContext)) { await _dbContext.SaveChangesAsync(); await _pageStoredProcedures.UpdatePublishStatusQueryLookupAsync(command.PageId); scope.QueueCompletionTask(() => OnTransactionComplete(command)); await scope.CompleteAsync(); } } }
public async Task ExecuteAsync(ReOrderCustomEntitiesCommand command, IExecutionContext executionContext) { var definition = _customEntityDefinitionRepository.GetByCode(command.CustomEntityDefinitionCode) as IOrderableCustomEntityDefinition; if (definition == null || definition.Ordering == CustomEntityOrdering.None) { throw new InvalidOperationException("Cannot re-order a custom entity type with a definition that does not implement IOrderableCustomEntityDefinition (" + definition.GetType().Name + ")"); } if (!definition.HasLocale && command.LocaleId.HasValue) { throw new ValidationException("Cannot order by locale because this custom entity type is not permitted to have a locale (" + definition.GetType().FullName + ")"); } var affectedIds = await _customEntityStoredProcedures.ReOrderAsync( command.CustomEntityDefinitionCode, command.OrderedCustomEntityIds, command.LocaleId ); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete(command, affectedIds)); }
public async Task ExecuteAsync(AddCustomEntityDraftVersionCommand command, IExecutionContext executionContext) { var definitionCode = await QueryVersionAndGetDefinitionCode(command).FirstOrDefaultAsync(); EntityNotFoundException.ThrowIfNull(definitionCode, command.CustomEntityId); _permissionValidationService.EnforceIsLoggedIn(executionContext.UserContext); _permissionValidationService.EnforceCustomEntityPermission <CustomEntityUpdatePermission>(definitionCode, executionContext.UserContext); var newVersionId = await _customEntityStoredProcedures.AddDraftAsync( command.CustomEntityId, command.CopyFromCustomEntityVersionId, executionContext.ExecutionDate, executionContext.UserContext.UserId.Value); command.OutputCustomEntityVersionId = newVersionId; await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete( command, definitionCode, newVersionId) ); }
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 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); _permissionValidationService.EnforceCustomEntityPermission <CustomEntityUpdatePermission>(dbResult.CustomEntityDefinitionCode, executionContext.UserContext); 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(); await _transactionScopeFactory.QueueCompletionTaskAsync(_dbContext, () => OnTransactionComplete( dbResult.CustomEntityDefinitionCode, dbResult.CustomEntityId, dbResult.Block.CustomEntityVersionPageBlockId) ); }