private IEnumerable <CustomEntityRenderSummary> Map(
ICollection <CustomEntityVersion> dbResults,
IDictionary <int, IEnumerable <PageRoutingInfo> > allRoutings,
IEnumerable <ActiveLocale> allLocalesAsEnumerable
)
{
var results = new List <CustomEntityRenderSummary>(dbResults.Count);
var allLocales = allLocalesAsEnumerable.ToDictionary(l => l.LocaleId);
foreach (var dbResult in dbResults)
{
var entity = Mapper.Map <CustomEntityRenderSummary>(dbResult);
if (dbResult.CustomEntity.LocaleId.HasValue)
{
entity.Locale = allLocales.GetOrDefault(dbResult.CustomEntity.LocaleId.Value);
EntityNotFoundException.ThrowIfNull(entity.Locale, dbResult.CustomEntity.LocaleId.Value);
}
entity.DetailsPageUrls = MapPageRoutings(allRoutings.GetOrDefault(dbResult.CustomEntityId), dbResult);
entity.Model = _customEntityDataModelMapper.Map(dbResult.CustomEntity.CustomEntityDefinitionCode, dbResult.SerializedData);
results.Add(entity);
}
return(results);
}
private User MapAndAddUser(AddMasterCofoundryUserCommand command, IExecutionContext executionContext, Role superUserRole, UserArea userArea)
{
var user = new User();
user.FirstName = command.FirstName;
user.LastName = command.LastName;
user.Username = command.Email;
user.Email = command.Email;
user.RequirePasswordChange = false;
user.LastPasswordChangeDate = executionContext.ExecutionDate;
user.CreateDate = executionContext.ExecutionDate;
user.Role = superUserRole;
var hashResult = _passwordCryptographyService.CreateHash(command.Password);
user.Password = hashResult.Hash;
user.PasswordEncryptionVersion = (int)hashResult.EncryptionVersion;
user.UserArea = userArea;
EntityNotFoundException.ThrowIfNull(user.UserArea, CofoundryAdminUserArea.AreaCode);
_dbContext.Users.Add(user);
return(user);
}
private ICollection <CustomEntityRenderSummary> Map(
ICollection <CustomEntityVersion> dbResults,
IDictionary <int, ICollection <PageRoutingInfo> > allRoutings,
ICollection <ActiveLocale> allLocalesAsEnumerable
)
{
var results = new List <CustomEntityRenderSummary>(dbResults.Count);
var allLocales = allLocalesAsEnumerable.ToDictionary(l => l.LocaleId);
foreach (var dbResult in dbResults)
{
var entity = MapCore(dbResult);
if (dbResult.CustomEntity.LocaleId.HasValue)
{
entity.Locale = allLocales.GetOrDefault(dbResult.CustomEntity.LocaleId.Value);
EntityNotFoundException.ThrowIfNull(entity.Locale, dbResult.CustomEntity.LocaleId.Value);
}
entity.PageUrls = MapPageRoutings(allRoutings.GetOrDefault(dbResult.CustomEntityId), dbResult);
results.Add(entity);
}
return(results);
}
public async Task ExecuteAsync(AddCustomEntityDraftVersionCommand command, IExecutionContext executionContext)
{
var definitionCode = await QueryVersionAndGetDefinitionCode(command).FirstOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(definitionCode, command.CustomEntityId);
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityUpdatePermission>(definitionCode);
var newVersionId = await _entityFrameworkSqlExecutor
.ExecuteCommandWithOutputAsync <int?>("Cofoundry.CustomEntity_AddDraft",
"CustomEntityVersionId",
new SqlParameter("CustomEntityId", command.CustomEntityId),
new SqlParameter("CopyFromCustomEntityVersionId", command.CopyFromCustomEntityVersionId),
new SqlParameter("CreateDate", executionContext.ExecutionDate),
new SqlParameter("CreatorId", executionContext.UserContext.UserId)
);
if (!newVersionId.HasValue)
{
throw new UnexpectedSqlStoredProcedureResultException("Cofoundry.CustomEntity_AddDraft", "No CustomEntityVersionId was returned.");
}
command.OutputCustomEntityVersionId = newVersionId.Value;
_customEntityCache.Clear(definitionCode, command.CustomEntityId);
await _messageAggregator.PublishAsync(new CustomEntityDraftVersionAddedMessage()
{
CustomEntityId = command.CustomEntityId,
CustomEntityVersionId = newVersionId.Value,
CustomEntityDefinitionCode = definitionCode
});
}
private void SetDraftVersionPublished(PublishPageCommand command, List <PageVersion> pageVersions)
{
var draftVersion = pageVersions.SingleOrDefault(v => v.WorkFlowStatusId == (int)WorkFlowStatus.Draft);
EntityNotFoundException.ThrowIfNull(draftVersion, "Draft:" + command.PageId);
draftVersion.WorkFlowStatusId = (int)WorkFlowStatus.Published;
}
public async Task Update(Guid id, ProductModel model)
{
var query = _readOnlyRepository.Query <Product>(x => x.Id.Equals(id))
.ProjectTo <ProductModel>(_mapper.ConfigurationProvider);
var result = await _readOnlyRepository.SingleAsync(query);
if (result != null)
{
//result.Id = id;
//result.ProductName = model.ProductName;
//result.Description = model.Description;
//result.Characteristics = model.Characteristics;
//result.Price = model.Price;
////result.Category = model.Category;
//result.CategoryId = model.CategoryId;
var entity = _mapper.Map <Product>(model);
entity.Id = id;
entity.CategoryId = model.CategoryId;
_repository.Update(entity);
await _repository.SaveChangesAsync();
}
else
{
throw EntityNotFoundException.For <Product>(id);
}
}
public void And_Using_Message_Ctor_Then_Sets_Message_From_Param(
string message)
{
var exception = new EntityNotFoundException <TestEntity>(message);
exception.Message.Should().Be(message);
}
private async Task <CustomEntityVersionPageBlockRenderDetails> MapAsync(
CustomEntityVersionPageBlock versionBlock,
string blockTypeFileName,
string customEntityDefinitionCode,
PublishStatusQuery publishStatus,
IExecutionContext executionContext
)
{
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityReadPermission>(customEntityDefinitionCode, executionContext.UserContext);
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,
executionContext
);
return(result);
}
public EntityNotExistsDetails(EntityNotFoundException exception)
{
Title = $"Can't find {exception.TypeName}.";
Status = StatusCodes.Status404NotFound;
Detail = exception.Message;
Type = $"https://httpstatuses.com/{Status}";
}
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();
_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 <ProductsModel> Get(Guid id)
{
var query = _readOnlyRepository.Query <Product>(x => x.Id == id && x.Status == EnabledStatus.Enabled)
.ProjectTo <ProductsModel>(_mapper.ConfigurationProvider);
var queryCategory = _readOnlyRepository.Query <ProductCat>(x => x.Status == EnabledStatus.Enabled && x.ProductId == id, y => y.Category).ToList();
var result = await _readOnlyRepository.SingleAsync(query);
if (result == null)
{
throw EntityNotFoundException.For <Product>(id);
}
if (result.ProductDetails != null)
{
result.ProductDetails = result.ProductDetails.Where(x => x.Status == EnabledStatus.Enabled).ToList();
}
result.Categories = new List <Category>();
queryCategory.ForEach(x => {
result.Categories.Add(new Category {
Id = x.Category.Id,
Name = x.Category.Name,
Description = x.Category.Description
});
});
return(result);
}
private async Task <IDictionary <int, ICollection <PageRoutingInfo> > > MapAsync(IExecutionContext executionContext, List <IdQueryResult> idSets, Dictionary <int, CustomEntityRoute> customEntityRoutes, IDictionary <int, PageRoute> pageRoutes)
{
var allRules = await _queryExecutor.ExecuteAsync(new GetAllCustomEntityRoutingRulesQuery(), executionContext);
var result = new List <PageRoutingInfo>(idSets.Count);
foreach (var idSet in idSets)
{
var routingInfo = new PageRoutingInfo();
routingInfo.PageRoute = pageRoutes.GetOrDefault(idSet.PageId);
EntityNotFoundException.ThrowIfNull(routingInfo.PageRoute, idSet.PageId);
routingInfo.CustomEntityRoute = customEntityRoutes.GetOrDefault(idSet.CustomEntityId);
EntityNotFoundException.ThrowIfNull(routingInfo.CustomEntityRoute, idSet.PageId);
routingInfo.CustomEntityRouteRule = allRules.FirstOrDefault(r => r.RouteFormat == routingInfo.PageRoute.UrlPath);
result.Add(routingInfo);
}
var groupedResult = result
.GroupBy(r => r.CustomEntityRoute.CustomEntityId)
.ToDictionary(g => g.Key, g => (ICollection <PageRoutingInfo>)g.ToList());
return(groupedResult);
}
private async Task <PageVersionBlockRenderDetails> MapAsync(
PageVersionBlock pageVersionBlock,
string blockTypeFileName,
PublishStatusQuery publishStatus,
IExecutionContext executionContext
)
{
var blockTypeQuery = new GetPageBlockTypeSummaryByIdQuery(pageVersionBlock.PageBlockTypeId);
var blockType = await _queryExecutor.ExecuteAsync(blockTypeQuery, executionContext);
EntityNotFoundException.ThrowIfNull(blockType, pageVersionBlock.PageBlockTypeId);
var result = new PageVersionBlockRenderDetails();
result.PageVersionBlockId = pageVersionBlock.PageVersionBlockId;
result.BlockType = blockType;
result.DisplayModel = await _pageVersionBlockModelMapper.MapDisplayModelAsync(
blockTypeFileName,
pageVersionBlock,
publishStatus,
executionContext
);
return(result);
}
public async Task ExecuteAsync(EnsureCustomEntityDefinitionExistsCommand command, IExecutionContext executionContext)
{
var customEntityDefinition = _customEntityDefinitionRepository.GetByCode(command.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(customEntityDefinition, command.CustomEntityDefinitionCode);
var dbDefinition = await _dbContext
.CustomEntityDefinitions
.FilterByCode(command.CustomEntityDefinitionCode)
.SingleOrDefaultAsync();
if (dbDefinition == null)
{
await _commandExecutor.ExecuteAsync(new EnsureEntityDefinitionExistsCommand(command.CustomEntityDefinitionCode));
dbDefinition = new CustomEntityDefinition()
{
CustomEntityDefinitionCode = customEntityDefinition.CustomEntityDefinitionCode,
ForceUrlSlugUniqueness = customEntityDefinition.ForceUrlSlugUniqueness,
HasLocale = customEntityDefinition.HasLocale
};
if (customEntityDefinition is IOrderableCustomEntityDefinition)
{
dbDefinition.IsOrderable = ((IOrderableCustomEntityDefinition)customEntityDefinition).Ordering != CustomEntityOrdering.None;
}
_dbContext.CustomEntityDefinitions.Add(dbDefinition);
await _dbContext.SaveChangesAsync();
}
}
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 UpdateModelAsync(IPageVersionModuleDataModelCommand command, IEntityVersionPageModule dbModule)
{
if (command.PageModuleTypeId != dbModule.PageModuleTypeId)
{
var pageTemplateSectionId = dbModule.PageTemplateSection != null ? dbModule.PageTemplateSection.PageTemplateSectionId : dbModule.PageTemplateSectionId;
var pageModuleType = await _dbContext
.PageModuleTypes
.Where(m => m.PageModuleTypeId == command.PageModuleTypeId)
.SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(pageModuleType, command.PageModuleTypeId);
dbModule.PageModuleType = pageModuleType;
}
dbModule.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.DataModel);
if (command.PageModuleTypeTemplateId != dbModule.PageModuleTypeTemplateId && command.PageModuleTypeTemplateId.HasValue)
{
dbModule.PageModuleTypeTemplate = await _dbContext
.PageModuleTypeTemplates
.SingleOrDefaultAsync(m => m.PageModuleTypeId == command.PageModuleTypeId && m.PageModuleTypeTemplateId == command.PageModuleTypeTemplateId);
EntityNotFoundException.ThrowIfNull(dbModule.PageModuleTypeTemplate, command.PageModuleTypeTemplateId);
}
else if (command.PageModuleTypeTemplateId != dbModule.PageModuleTypeTemplateId)
{
dbModule.PageModuleTypeTemplate = null;
}
}
public override async Task <KioskVersionGetResponse> ExecuteAsync(EmptyRequest request)
{
var kioskId = _currentUser.Id;
var kioskData = await _kioskManager.GetActiveKiosksQuery()
.Where(x => x.Id == kioskId)
.Select(x => new
{
x.ApplicationType,
x.AssignedKioskVersion,
})
.FirstOrDefaultAsync();
if (kioskData == null)
{
throw EntityNotFoundException.Create <Entities.Kiosk>(kioskId);
}
var response = new KioskVersionGetResponse()
{
AssignedKioskVersion = kioskData.AssignedKioskVersion,
};
if (!string.IsNullOrEmpty(response.AssignedKioskVersion))
{
response.AssignedKioskVersionUpdateUrl = await _kioskVersionUpdateManager.GetUpdateUrlAsync(
kioskData.ApplicationType,
response.AssignedKioskVersion);
}
return(response);
}
public async Task ExecuteAsync(UpdatePageVersionBlockCommand command, IExecutionContext executionContext)
{
var dbBlock = await _dbContext
.PageVersionBlocks
.Include(m => m.PageBlockTypeTemplate)
.Include(m => m.PageBlockType)
.Include(m => m.PageVersion)
.Where(l => l.PageVersionBlockId == command.PageVersionBlockId)
.SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(dbBlock, command.PageVersionBlockId);
if (dbBlock.PageVersion.WorkFlowStatusId != (int)WorkFlowStatus.Draft)
{
throw new NotPermittedException("Page blocks cannot be updated unless the page version is in draft status");
}
if (command.PageBlockTypeId != dbBlock.PageBlockTypeId)
{
var pageBlockType = await _dbContext
.PageBlockTypes
.Where(m => m.PageBlockTypeId == command.PageBlockTypeId)
.SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(pageBlockType, command.PageBlockTypeId);
dbBlock.PageBlockType = pageBlockType;
}
dbBlock.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.DataModel);
dbBlock.UpdateDate = executionContext.ExecutionDate;
if (command.PageBlockTypeTemplateId != dbBlock.PageBlockTypeTemplateId && command.PageBlockTypeTemplateId.HasValue)
{
dbBlock.PageBlockTypeTemplate = await _dbContext
.PageBlockTypeTemplates
.SingleOrDefaultAsync(m => m.PageBlockTypeId == dbBlock.PageBlockTypeId && m.PageBlockTypeTemplateId == command.PageBlockTypeTemplateId);
EntityNotFoundException.ThrowIfNull(dbBlock.PageBlockTypeTemplate, command.PageBlockTypeTemplateId);
}
else if (command.PageBlockTypeTemplateId != dbBlock.PageBlockTypeTemplateId)
{
dbBlock.PageBlockTypeTemplate = null;
}
using (var scope = _transactionScopeFactory.Create(_dbContext))
{
await _dbContext.SaveChangesAsync();
var dependencyCommand = new UpdateUnstructuredDataDependenciesCommand(
PageVersionBlockEntityDefinition.DefinitionCode,
dbBlock.PageVersionBlockId,
command.DataModel);
await _commandExecutor.ExecuteAsync(dependencyCommand, executionContext);
scope.QueueCompletionTask(() => OnTransactionComplete(dbBlock));
await scope.CompleteAsync();
}
}
/// <summary>
/// Deletes the <see cref="TViewModel"/> with the specified identifier.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns></returns>
public async Task DeleteAsync(string id)
{
if (!await Repository.DeleteAsync(id, RequestAborted))
{
throw EntityNotFoundException.Create <TEntity>(x => x.Id, id);
}
}
private void SetCustomModelTypeFields(PageTemplateFileInfo pageTemplateFileInfo, string line, IExecutionContext ex)
{
const string CUSTOM_ENTITY_MODEL_REGEX = @"CustomEntityDetailsPageViewModel<(\w+)";
var match = Regex.Match(line, CUSTOM_ENTITY_MODEL_REGEX);
if (match.Success)
{
var modelType = _pageTemplateCustomEntityTypeMapper.Map(match.Groups[1].Value);
if (modelType == null)
{
throw new ApplicationException("ICustomEntityDisplayModel<T> of type " + match.Value + " not registered");
}
var query = new GetCustomEntityDefinitionMicroSummaryByDisplayModelTypeQuery();
query.DisplayModelType = modelType;
pageTemplateFileInfo.CustomEntityDefinition = _queryExecutor.Execute(query, ex);
EntityNotFoundException.ThrowIfNull(pageTemplateFileInfo.CustomEntityDefinition, modelType);
pageTemplateFileInfo.CustomEntityModelType = match.Groups[1].Value;
pageTemplateFileInfo.PageType = PageType.CustomEntityDetails;
}
}
private CustomEntityDefinitionSummary GetCustomEntityDefinition(AddCustomEntityCommand command)
{
var definition = _queryExecutor.GetById <CustomEntityDefinitionSummary>(command.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, command.CustomEntityDefinitionCode);
return(definition);
}
private async Task SetCustomModelTypeFieldsAsync(
PageTemplateFileInfo pageTemplateFileInfo,
string line,
IExecutionContext executionContext
)
{
// This regex find models with generic parameters and captures the last generic type
// This could be the custom entity display model type and may have a namespace prefix
const string CUSTOM_ENTITY_MODEL_REGEX = @"\s*@(?:inherits|model)\s+[\w+<.]*<([\w\.]+)";
var match = Regex.Match(line, CUSTOM_ENTITY_MODEL_REGEX);
if (match.Success)
{
// Try and find a matching custom entity model type.
var modelType = _pageTemplateCustomEntityTypeMapper.Map(match.Groups[1].Value);
if (modelType == null)
{
return;
}
var query = new GetCustomEntityDefinitionMicroSummaryByDisplayModelTypeQuery();
query.DisplayModelType = modelType;
pageTemplateFileInfo.CustomEntityDefinition = await _queryExecutor.ExecuteAsync(query, executionContext);
EntityNotFoundException.ThrowIfNull(pageTemplateFileInfo.CustomEntityDefinition, modelType);
pageTemplateFileInfo.CustomEntityModelType = match.Groups[1].Value;
pageTemplateFileInfo.PageType = PageType.CustomEntityDetails;
}
}
public async Task <UpdatePageDirectoryCommand> ExecuteAsync(GetUpdateCommandByIdQuery <UpdatePageDirectoryCommand> query, IExecutionContext executionContext)
{
var dbResult = await _dbContext
.PageDirectories
.AsNoTracking()
.Where(w => w.PageDirectoryId == query.Id && w.IsActive)
.SingleOrDefaultAsync();
EntityNotFoundException.ThrowIfNull(dbResult, query.Id);
if (!dbResult.ParentPageDirectoryId.HasValue)
{
throw new NotPermittedException("The root directory cannot be updated.");
}
var command = new UpdatePageDirectoryCommand()
{
Name = dbResult.Name,
PageDirectoryId = dbResult.PageDirectoryId,
ParentPageDirectoryId = dbResult.ParentPageDirectoryId.Value,
UrlPath = dbResult.UrlPath
};
return(command);
}
private async Task UpdateTemplates(
IExecutionContext executionContext,
ILookup <string, PageTemplate> dbPageTemplates,
ICollection <PageTemplateFile> fileTemplates
)
{
foreach (var fileTemplate in fileTemplates)
{
var fileTemplateDetails = await _queryExecutor.ExecuteAsync(new GetPageTemplateFileInfoByPathQuery(fileTemplate.VirtualPath), executionContext);
EntityNotFoundException.ThrowIfNull(fileTemplateDetails, fileTemplate.VirtualPath);
var dbPageTemplate = EnumerableHelper.Enumerate(dbPageTemplates[fileTemplate.FileName])
.OrderBy(t => t.IsArchived)
.ThenByDescending(t => t.UpdateDate)
.FirstOrDefault();
// Run this first because it may commit changes
await EnsureCustomEntityDefinitionExistsAsync(fileTemplateDetails, dbPageTemplate, executionContext);
dbPageTemplate = await UpdateTemplate(executionContext, dbPageTemplate, fileTemplate, fileTemplateDetails);
// No need to update archived template regions
if (dbPageTemplate.IsArchived)
{
continue;
}
// Update Regions
UpdateRegions(fileTemplate, fileTemplateDetails, dbPageTemplate, executionContext);
}
}
private static Task HandleExceptionAsync(HttpContext context, Exception exception)
{
var code = exception switch
{
DisabledWorkerException _ => HttpStatusCode.Forbidden,
EntityNotFoundException _ => HttpStatusCode.NotFound,
InvalidParameterFormatException _ => HttpStatusCode.BadRequest,
_ => HttpStatusCode.InternalServerError,
};
var response = new ResponseDto <object>
{
Succeeded = false,
Errors = new List <string>()
{
exception.GetaAllMessages()
}
};
var result = JsonConvert.SerializeObject(response,
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
context.Response.ContentType = "application/json; charset=utf-8";
context.Response.StatusCode = (int)code;
return(context.Response.WriteAsync(result));
}
private async Task UpdateTemplates(
IExecutionContext executionContext,
Dictionary <string, PageTemplate> dbPageTemplates,
IEnumerable <PageTemplateFile> fileTemplates
)
{
foreach (var fileTemplate in fileTemplates)
{
var fileTemplateDetails = await _queryExecutor.ExecuteAsync(new GetPageTemplateFileInfoByPathQuery(fileTemplate.FullPath), executionContext);
EntityNotFoundException.ThrowIfNull(fileTemplateDetails, fileTemplate.FullPath);
var dbPageTemplate = dbPageTemplates.GetOrDefault(fileTemplate.FileName);
// Run this first because it may commit changes
await EnsureCustomEntityDefinitionExists(fileTemplateDetails, dbPageTemplate);
dbPageTemplate = await UpdateTemplate(executionContext, dbPageTemplate, fileTemplate, fileTemplateDetails);
// No need to update archived template sections
if (dbPageTemplate.IsArchived)
{
continue;
}
// Update Sections
UpdateSections(fileTemplate, fileTemplateDetails, dbPageTemplate, executionContext);
}
}
protected virtual Location HandleLocationNotFound(PL patientLocation, EntityNotFoundException e)
{
string locationName = patientLocation.PointOfCare.Value;
Facility facility;
try
{
facility = FindFacility(patientLocation.Facility.NamespaceID.Value, PersistenceContext);
}
catch (Exception)
{
facility = null;
}
var location = new Location
{
Id = locationName,
Name = locationName,
PointOfCare = locationName,
Facility = facility,
Deactivated = false,
Description = "HL7"
};
PersistenceContext.Lock(location, DirtyState.New);
return(location);
}
private void UpdateDraft(UpdateCustomEntityDraftVersionCommand command, CustomEntityVersion draft)
{
EntityNotFoundException.ThrowIfNull(draft, "Draft:" + command.CustomEntityId);
draft.Title = command.Title.Trim();
draft.SerializedData = _dbUnstructuredDataSerializer.Serialize(command.Model);
}
public async Task ExecuteAsync(AddMasterCofoundryUserCommand command, IExecutionContext executionContext)
{
var settings = _queryExecutor.Get <InternalSettings>();
if (settings.IsSetup)
{
throw new ValidationException("Site is already set up.");
}
if (await _dbContext
.Users
.FilterCanLogIn()
.AnyAsync(u => u.Role.SpecialistRoleTypeCode == SpecialistRoleTypeCodes.SuperAdministrator))
{
throw new ValidationException("Cannot create a master user when master users already exist in the database.");
}
var role = await _dbContext
.Roles
.SingleOrDefaultAsync(r => r.SpecialistRoleTypeCode == SpecialistRoleTypeCodes.SuperAdministrator);
EntityNotFoundException.ThrowIfNull(role, SpecialistRoleTypeCodes.SuperAdministrator);
var userArea = await _dbContext
.UserAreas
.SingleOrDefaultAsync(a => a.UserAreaCode == CofoundryAdminUserArea.AreaCode);
var user = MapAndAddUser(command, executionContext, role, userArea);
await _dbContext.SaveChangesAsync();
command.OutputUserId = user.UserId;
}
public async Task ExecuteAsync(DeleteUnstructuredDataDependenciesCommand command, IExecutionContext executionContext)
{
string entityName;
var entityDefinition = _entityDefinitionRepository.GetByCode(command.RootEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(entityDefinition, command.RootEntityDefinitionCode);
entityName = entityDefinition.Name;
var query = new GetEntityDependencySummaryByRelatedEntityQuery(command.RootEntityDefinitionCode, command.RootEntityId);
var dependencies = await _queryExecutor.ExecuteAsync(query, executionContext);
var requiredDependency = dependencies.FirstOrDefault(d => !d.CanDelete);
if (requiredDependency != null)
{
throw new ValidationException(
string.Format("Cannot delete this {0} because {1} '{2}' has a dependency on it.",
entityName,
requiredDependency.Entity.EntityDefinitionName.ToLower(),
requiredDependency.Entity.RootEntityTitle));
}
await _entityFrameworkSqlExecutor
.ExecuteCommandAsync(_dbContext,
"Cofoundry.UnstructuredDataDependency_Delete",
new SqlParameter("EntityDefinitionCode", command.RootEntityDefinitionCode),
new SqlParameter("EntityId", command.RootEntityId)
);
}
public void GivenExceptionHasBeenHandled_AndExceptionIsEntityNotFoundException_WhenOnException_ThenResultNull_AndStatusNotChanged()
{
EntityNotFoundException exception = new EntityNotFoundException();
ExceptionContext context = ControllerContextFactory.CreateExceptionContext(MockHttpContext, exception);
context.ExceptionHandled = true;
Target.OnException(context);
Assert.IsInstanceOfType(context.Result, typeof(EmptyResult));
MockHttpContext.Response.AssertWasNotCalled(m => m.StatusCode = Arg<int>.Is.Anything);
}
public void GivenExceptionIsEntityNotFoundException_WhenOnException_ThenHttpNotFound()
{
EntityNotFoundException exception = new EntityNotFoundException();
ExceptionContext context = ControllerContextFactory.CreateExceptionContext(MockHttpContext, exception);
Target.OnException(context);
HttpNotFoundResult actual = context.Result as HttpNotFoundResult;
Assert.IsNotNull(actual);
MockHttpContext.Response.AssertWasCalled(m => m.StatusCode = 404);
}
public void GivenExceptionIsEntityNotFoundException_WhenOnException_ThenExceptionHandled()
{
EntityNotFoundException exception = new EntityNotFoundException();
ExceptionContext context = ControllerContextFactory.CreateExceptionContext(MockHttpContext, exception);
Target.OnException(context);
Assert.IsTrue(context.ExceptionHandled);
}
public void GivenExceptionIsEntityNotFoundException_WhenOnException_ThenHttpDescriptionIsExceptionMessage()
{
string expected = "blah blah exception message and stuff";
EntityNotFoundException exception = new EntityNotFoundException(expected);
ExceptionContext context = ControllerContextFactory.CreateExceptionContext(MockHttpContext, exception);
Target.OnException(context);
HttpStatusCodeResult actual = context.Result as HttpStatusCodeResult;
Assert.AreEqual(expected, actual.StatusDescription);
}
public void GivenResponseHasBeenWrittenTo_ExceptionIsEntityNotFoundException_WhenOnException_ThenResponseHasBeenCleared()
{
EntityNotFoundException exception = new EntityNotFoundException();
ExceptionContext context = ControllerContextFactory.CreateExceptionContext(MockHttpContext, exception);
Target.OnException(context);
MockHttpContext.Response.AssertWasCalled(m => m.Clear());
}
