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)
{
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityUpdatePermission>(dbResult.CustomEntityDefinitionCode, executionContext.UserContext);
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;
_dbContext.CustomEntityVersionPageBlocks.Remove(dbResult.Block);
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, () => OnTransactionComplete(dbResult.CustomEntityDefinitionCode, dbResult.CustomEntityId, customEntityVersionBlockId));
}
}
public async Task ExecuteAsync(DeletePageVersionBlockCommand command, IExecutionContext executionContext)
{
var dbResult = await _dbContext
.PageVersionBlocks
.Where(b => b.PageVersionBlockId == command.PageVersionBlockId)
.Select(b => new
{
Block = b,
PageId = b.PageVersion.PageId,
WorkFlowStatusId = b.PageVersion.WorkFlowStatusId
})
.SingleOrDefaultAsync();
if (dbResult != null)
{
if (dbResult.WorkFlowStatusId != (int)WorkFlowStatus.Draft)
{
throw new NotPermittedException("Page blocks cannot be deleted unless the page version is in draft status");
}
var versionId = dbResult.Block.PageVersionId;
_dbContext.PageVersionBlocks.Remove(dbResult.Block);
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, () => OnTransactionComplete(dbResult.PageId, versionId));
}
}
public async Task ExecuteAsync(RegisterPageBlockTypesCommand command, IExecutionContext executionContext)
{
var dbPageBlockTypes = await _dbContext
.PageBlockTypes
.Include(t => t.PageBlockTemplates)
.ToDictionaryAsync(d => d.FileName);
DetectDuplicateBlockTypes();
var blockTypeDataModels = _allPageBlockTypeDataModels
.ToDictionary(m => FormatBlockTypeFileName(m));
await DeleteBlockTypes(executionContext, dbPageBlockTypes, blockTypeDataModels);
await UpdateBlocksAsync(executionContext, dbPageBlockTypes, blockTypeDataModels);
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _pageCache.Clear);
_transactionScopeFactory.QueueCompletionTask(_dbContext, _blockCache.Clear);
}
public async Task ExecuteAsync(UpdateSeoSettingsCommand command, IExecutionContext executionContext)
{
var allSettings = await _dbContext
.Settings
.ToListAsync();
_settingCommandHelper.SetSettingProperty(command, c => c.HumansTxt, allSettings, executionContext);
_settingCommandHelper.SetSettingProperty(command, c => c.RobotsTxt, allSettings, executionContext);
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _settingCache.Clear);
}
public async Task ExecuteAsync(UpdatePageDirectoryCommand command, IExecutionContext executionContext)
{
Normalize(command);
var pageDirectory = await _dbContext
.PageDirectories
.FilterById(command.PageDirectoryId)
.SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(pageDirectory, command.PageDirectoryId);
pageDirectory.Name = command.Name;
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _cache.Clear);
}
public async Task ExecuteAsync(DeleteRoleCommand command, IExecutionContext executionContext)
{
var role = await _dbContext
.Roles
.FilterById(command.RoleId)
.SingleOrDefaultAsync();
if (role != null)
{
ValidateCanDelete(role, command);
_dbContext.Roles.Remove(role);
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, () => _roleCache.Clear(command.RoleId));
}
}
public async Task ExecuteAsync(UpdateGeneralSiteSettingsCommand command, IExecutionContext executionContext)
{
var allSettings = await _dbContext
.Settings
.ToListAsync();
_settingCommandHelper.SetSettingProperty(command, c => c.ApplicationName, allSettings, executionContext);
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _dbContext.SaveChangesAsync();
await _autoUpdateService.SetLockedAsync(!command.AllowAutomaticUpdates);
await scope.CompleteAsync();
}
_transactionScopeFactory.QueueCompletionTask(_dbContext, _settingCache.Clear);
}
public async Task ExecuteAsync(UpdateRoleCommand command, IExecutionContext executionContext)
{
ValidatePermissions(command);
var role = await QueryRole(command).SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(role, command.RoleId);
var isUnique = await _queryExecutor.ExecuteAsync(GetUniqueQuery(command, role), executionContext);
ValidateIsUnique(isUnique);
MapRole(command, role);
await MergePermissionsAsync(command, role, executionContext);
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, () => _roleCache.Clear(command.RoleId));
}
public async Task ExecuteAsync(AddPageDirectoryCommand command, IExecutionContext executionContext)
{
// Custom Validation
await ValidateIsUniqueAsync(command, executionContext);
var pageDirectory = new PageDirectory();
pageDirectory.Name = command.Name;
pageDirectory.UrlPath = command.UrlPath;
pageDirectory.ParentPageDirectoryId = command.ParentPageDirectoryId;
_entityAuditHelper.SetCreated(pageDirectory, executionContext);
_dbContext.PageDirectories.Add(pageDirectory);
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _cache.Clear);
command.OutputPageDirectoryId = pageDirectory.PageDirectoryId;
}
public async Task ExecuteAsync(UpdatePageDirectoryCommand command, IExecutionContext executionContext)
{
var pageDirectory = await _dbContext
.PageDirectories
.SingleOrDefaultAsync(w => w.PageDirectoryId == command.PageDirectoryId);
EntityNotFoundException.ThrowIfNull(pageDirectory, command.PageDirectoryId);
// Custom Validation
await ValidateIsUniqueAsync(command, executionContext);
await ValidateUrlPropertiesAllowedToChange(command, pageDirectory);
pageDirectory.Name = command.Name;
pageDirectory.UrlPath = command.UrlPath;
pageDirectory.ParentPageDirectoryId = command.ParentPageDirectoryId;
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _cache.Clear);
}
public async Task ExecuteAsync(RegisterPageTemplatesCommand command, IExecutionContext executionContext)
{
var dbPageTemplates = (await _dbContext
.PageTemplates
.Include(t => t.PageTemplateRegions)
.ToListAsync())
.ToLookup(d => d.FileName);
var fileTemplates = _pageTemplateViewFileLocator
.GetPageTemplateFiles()
.ToList();
DetectDuplicateTemplates(fileTemplates);
// Mark removed templates as deleted
await DeleteTemplates(executionContext, dbPageTemplates, fileTemplates);
await UpdateTemplates(executionContext, dbPageTemplates, fileTemplates);
// Save changes
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _pageCache.Clear);
}
public async Task ExecuteAsync(MarkAsSetUpCommand command, IExecutionContext executionContext)
{
_permissionValidationService.EnforceIsSuperAdminRole(executionContext.UserContext);
var setting = await _dbContext
.Settings
.SingleOrDefaultAsync(s => s.SettingKey == SETTING_KEY);
if (setting == null)
{
setting = new Setting();
setting.SettingKey = SETTING_KEY;
setting.CreateDate = executionContext.ExecutionDate;
setting.UpdateDate = executionContext.ExecutionDate;
_dbContext.Settings.Add(setting);
}
setting.SettingValue = "true";
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _settingCache.Clear);
}
public async Task ExecuteAsync(RegisterPermissionsAndRolesCommand command, IExecutionContext executionContext)
{
DetectDuplicateRoles();
// ENTITY DEFINITIONS
var dbEntityDefinitions = await _dbContext
.EntityDefinitions
.ToDictionaryAsync(e => e.EntityDefinitionCode);
await EnsureAllEntityDefinitionsExistAsync(dbEntityDefinitions);
// PERMISSIONS
// permissions already registered in the database
var dbPermissions = await _dbContext
.Permissions
.ToDictionaryAsync(p => p.GetUniqueCode());
// code-based permission objects
var codePermissions = _permissionRepository.GetAll();
var newCodePermissions = codePermissions
.Where(p => !dbPermissions.ContainsKey(p.GetUniqueCode()))
.ToList();
// Add new permissions to db
AddNewPermissionsToDb(dbEntityDefinitions, dbPermissions, newCodePermissions);
// ROLES
var dbRoles = await _dbContext
.Roles
.Include(r => r.RolePermissions)
.ThenInclude(p => p.Permission)
.ToListAsync();
var dbRolesWithCodes = dbRoles
.Where(r => !string.IsNullOrEmpty(r.RoleCode))
.ToDictionary(r => r.RoleCode.ToUpperInvariant());
await EnsureUserAreaExistsAndValidatePermissionAsync(dbRoles, executionContext);
foreach (var roleDefinition in _roleDefinitions)
{
var dbRole = dbRolesWithCodes.GetOrDefault(roleDefinition.RoleCode.ToUpperInvariant());
if (dbRole == null)
{
// New role
ValidateRole(dbRoles, roleDefinition);
dbRole = MapAndAddRole(roleDefinition);
UpdatePermissions(dbRole, roleDefinition, codePermissions, dbPermissions, dbEntityDefinitions, false);
}
else if (command.UpdateExistingRoles)
{
// Existing role, to be updated to match initializer exactly
UpdatePermissions(dbRole, roleDefinition, codePermissions, dbPermissions, dbEntityDefinitions, true);
}
else
{
// Update for new permissions only
UpdatePermissions(dbRole, roleDefinition, newCodePermissions, dbPermissions, dbEntityDefinitions, false);
}
}
await _dbContext.SaveChangesAsync();
_transactionScopeFactory.QueueCompletionTask(_dbContext, _roleCache.Clear);
}