public void GetQuery_Ask_ResultIsRight()
{
var q = new GetByIdQuery <int, Product, ProductDto>(_linqProvider, new StaticAutoMapperWrapper());
var res = q.Ask(5);
Assert.Equal(5, res.Id);
}
public DocumentAssetFile Execute(GetByIdQuery <DocumentAssetFile> query, IExecutionContext executionContext)
{
var dbResult = _dbContext
.DocumentAssets
.Where(f => f.DocumentAssetId == query.Id && !f.IsDeleted)
.Select(f => new {
Extension = f.FileExtension,
ContentType = f.ContentType,
FileName = f.Title
})
.SingleOrDefault();
if (dbResult == null)
{
return(null);
}
var fileName = Path.ChangeExtension(query.Id.ToString(), dbResult.Extension);
var result = new DocumentAssetFile();
result.DocumentAssetId = query.Id;
result.ContentType = dbResult.ContentType;
result.ContentStream = _fileStoreService.Get(DocumentAssetConstants.FileContainerName, fileName);
result.FileName = FilePathHelper.CleanFileName(Path.ChangeExtension(dbResult.FileName, dbResult.Extension), fileName);
if (result.ContentStream == null)
{
throw new FileNotFoundException("DocumentAsset file could not be found", fileName);
}
return(result);
}
private async Task <CustomEntityDetails> Map(
GetByIdQuery <CustomEntityDetails> query,
CustomEntityVersion dbVersion,
IExecutionContext executionContext)
{
if (dbVersion == null)
{
return(null);
}
var entity = Mapper.Map <CustomEntityDetails>(dbVersion.CustomEntity);
entity.LatestVersion = Mapper.Map <CustomEntityVersionDetails>(dbVersion);
entity.HasDraft = entity.LatestVersion.WorkFlowStatus == WorkFlowStatus.Draft;
entity.IsPublished = entity.LatestVersion.WorkFlowStatus == WorkFlowStatus.Published;
if (!entity.IsPublished)
{
entity.IsPublished = await _dbContext
.CustomEntityVersions
.AnyAsync(v => v.CustomEntityId == query.Id && v.WorkFlowStatusId == (int)WorkFlowStatus.Published);
}
// Custom Mapping
MapDataModel(query, dbVersion, entity.LatestVersion);
await MapPages(dbVersion, entity, executionContext);
return(entity);
}
public async Task <UpdateUserCommand> ExecuteAsync(GetByIdQuery <UpdateUserCommand> query, IExecutionContext executionContext)
{
var dbUser = await _dbContext
.Users
.AsNoTracking()
.FilterCanLogIn()
.FilterById(query.Id)
.SingleOrDefaultAsync();
if (dbUser == null)
{
return(null);
}
if (dbUser.UserAreaCode == CofoundryAdminUserArea.AreaCode)
{
_permissionValidationService.EnforceCurrentUserOrHasPermission <CofoundryUserReadPermission>(query.Id, executionContext.UserContext);
}
else
{
_permissionValidationService.EnforceCurrentUserOrHasPermission <NonCofoundryUserReadPermission>(query.Id, executionContext.UserContext);
}
var user = _mapper.Map <UpdateUserCommand>(dbUser);
return(user);
}
public PageDetails Execute(GetByIdQuery <PageDetails> query, IExecutionContext executionContext)
{
var page = GetPageById(query.Id).FirstOrDefault();
var sections = _queryExecutor.Execute(GetSectionQuery(page));
return(Map(query, page, sections));
}
public async Task <DocumentAssetRenderDetails> ExecuteAsync(GetByIdQuery <DocumentAssetRenderDetails> query, IExecutionContext executionContext)
{
var result = await Query(query)
.SingleOrDefaultAsync();
return(result);
}
public async Task <OfferDto> Handle(GetByIdQuery <int, OfferDto> request, CancellationToken cancellationToken)
{
var query = _context.Offers.Where(x => x.Id == request.Id && !x.IsDeleted)
.ProjectTo <OfferDto>(_mapper.ConfigurationProvider);
return(await query.SingleOrDefaultAsync(cancellationToken));
}
public DocumentAssetRenderDetails Execute(GetByIdQuery <DocumentAssetRenderDetails> query, IExecutionContext executionContext)
{
var result = Query(query)
.SingleOrDefault();
return(result);
}
public async Task <ResponseModel <Data.Category> > Handle(GetByIdQuery request, CancellationToken cancellationToken)
{
var response = new ResponseModel <Data.Category>()
{
Status = HttpStatusCode.InternalServerError,
IsSuccessful = false,
Result = default,
public IOperationResult Update(Guid oid, TEntity entity)
{
OperationResult = new OperationResult();
try
{
var query = new GetByIdQuery <TEntity>(oid);
var existingEntity = Context.Execute(query);
if (existingEntity == null)
{
OperationResult.Errors.Add(string.Format("The entity id {0} doesn't exist in the database.", oid));
}
else
{
var deleteCommand = new DeleteCommand <TEntity>(entity.Oid);
Context.Execute(deleteCommand);
var insertCommand = new InsertCommand <TEntity>(entity);
Context.Execute(insertCommand);
OperationResult.Oks.Add(string.Format("Entity {0} was succesfully updated.", entity.Oid));
}
}
catch (Exception ex)
{
OperationResult.Errors.Add(string.Format("An error occurred when retrieving entities from the context. Message: {0}", ex.Message));
}
return(OperationResult);
}
public PageRoute Execute(GetByIdQuery <PageRoute> query, IExecutionContext executionContext)
{
var result = _queryExecutor
.GetAll <PageRoute>()
.SingleOrDefault(p => p.PageId == query.Id);
return(result);
}
public async Task <CustomEntityDetails> ExecuteAsync(GetByIdQuery <CustomEntityDetails> query, IExecutionContext executionContext)
{
var customEntityVersion = await Query(query.Id).FirstOrDefaultAsync();
_permissionValidationService.EnforceCustomEntityPermission <CustomEntityReadPermission>(customEntityVersion.CustomEntity.CustomEntityDefinitionCode);
return(await Map(query, customEntityVersion, executionContext));
}
private void MapDataModel(GetByIdQuery <CustomEntityDetails> query, CustomEntityVersion dbVersion, CustomEntityVersionDetails version)
{
var definition = _queryExecutor.GetById <CustomEntityDefinitionSummary>(dbVersion.CustomEntity.CustomEntityDefinitionCode);
EntityNotFoundException.ThrowIfNull(definition, dbVersion.CustomEntity.CustomEntityDefinitionCode);
version.Model = (ICustomEntityVersionDataModel)_dbUnstructuredDataSerializer.Deserialize(dbVersion.SerializedData, definition.DataModelType);
}
public async Task <UpdateRoleCommand> ExecuteAsync(GetByIdQuery <UpdateRoleCommand> query, IExecutionContext executionContext)
{
var role = await _internalRoleRepository.GetByIdAsync(query.Id);
var command = Mapper.Map <UpdateRoleCommand>(role);
return(command);
}
public UserMicroSummary Execute(GetByIdQuery <UserMicroSummary> query, IExecutionContext executionContext)
{
var user = Query(query).SingleOrDefault();
ValidatePermission(query, executionContext, user);
return(user);
}
private IQueryable <DocumentAssetRenderDetails> Query(GetByIdQuery <DocumentAssetRenderDetails> query)
{
return(_dbContext
.DocumentAssets
.AsNoTracking()
.FilterById(query.Id)
.ProjectTo <DocumentAssetRenderDetails>());
}
public async Task <ActiveLocale> ExecuteAsync(GetByIdQuery <ActiveLocale> query, IExecutionContext executionContext)
{
var result = (await _queryExecutor
.GetAllAsync <ActiveLocale>())
.SingleOrDefault(l => l.LocaleId == query.Id);
return(result);
}
public async Task <UserMicroSummary> ExecuteAsync(GetByIdQuery <UserMicroSummary> query, IExecutionContext executionContext)
{
var user = await Query(query).SingleOrDefaultAsync();
ValidatePermission(query, executionContext, user);
return(user);
}
public async Task <PageRoute> ExecuteAsync(GetByIdQuery <PageRoute> query, IExecutionContext executionContext)
{
var result = (await _queryExecutor
.GetAllAsync <PageRoute>(executionContext))
.SingleOrDefault(p => p.PageId == query.Id);
return(result);
}
public ActiveLocale Execute(GetByIdQuery <ActiveLocale> query, IExecutionContext executionContext)
{
var result = _queryExecutor
.GetAll <ActiveLocale>()
.SingleOrDefault(l => l.LocaleId == query.Id);
return(result);
}
private IQueryable <UserMicroSummary> Query(GetByIdQuery <UserMicroSummary> query)
{
return(_dbContext
.Users
.AsNoTracking()
.Where(u => u.UserId == query.Id)
.ProjectTo <UserMicroSummary>());
}
public async Task <WebDirectoryRoute> ExecuteAsync(GetByIdQuery <WebDirectoryRoute> query, IExecutionContext executionContext)
{
var result = (await _queryExecutor
.GetAllAsync <WebDirectoryRoute>())
.SingleOrDefault(l => l.WebDirectoryId == query.Id);
return(result);
}
public WebDirectoryRoute Execute(GetByIdQuery <WebDirectoryRoute> query, IExecutionContext executionContext)
{
var result = _queryExecutor
.GetAll <WebDirectoryRoute>()
.SingleOrDefault(l => l.WebDirectoryId == query.Id);
return(result);
}
public async Task <PageDetails> ExecuteAsync(GetByIdQuery <PageDetails> query, IExecutionContext executionContext)
{
var page = await GetPageById(query.Id).FirstOrDefaultAsync();
var sections = await _queryExecutor.ExecuteAsync(GetSectionQuery(page));
return(Map(query, page, sections));
}
public async Task <UsersViewModel> FindByIdAsync(Guid id)
{
var query = new GetByIdQuery <Users, Guid>(id);
//var user = await _mediator.Send(new GetByIdQuery<Users>(id));
//var user = await Bus.SendQuery<GetByIdQuery<Users>>(new GetByIdQuery<Users>(id));
var user = await Bus.SendQuery(new GetByIdQuery <Users, Guid>(id));
return(_mapper.Map <UsersViewModel>(user));
}
public async Task <Users> Handle(GetByIdQuery <Users, Guid> request, CancellationToken cancellationToken)
{
if (request.Id == Guid.Empty)
{
throw new ArgumentException(nameof(request.Id));
}
return(await _usersRepository.FindByIdAsync(request.Id));
}
public WebDirectoryNode Execute(GetByIdQuery <WebDirectoryNode> query, IExecutionContext executionContext)
{
var tree = _queryExecutor.Execute(new GetWebDirectoryTreeQuery());
var result = tree
.Flatten()
.SingleOrDefault(n => n.WebDirectoryId == query.Id);
return(result);
}
public async Task <ImageAssetRenderDetails> ExecuteAsync(GetByIdQuery <ImageAssetRenderDetails> query, IExecutionContext executionContext)
{
var asset = await _imageAssetCache.GetOrAddAsync(query.Id, () =>
{
var result = Query(query.Id).SingleOrDefaultAsync();
return(result);
});
return(asset);
}
public ImageAssetRenderDetails Execute(GetByIdQuery <ImageAssetRenderDetails> query, IExecutionContext executionContext)
{
var asset = _imageAssetCache.GetOrAdd(query.Id, () =>
{
var result = Query(query.Id).SingleOrDefault();
return(result);
});
return(asset);
}
public async Task <T> Handle(GetByIdQuery <T> message)
{
var query = _db.Set <T>().AsNoTracking();
if (message.Include != null)
{
query = query.Include(message.Include);
}
return(await query.FirstOrDefaultAsync(x => x.Id == message.Id));
}
public Models.DomainModel.ProductName GetByIdHandler(GetByIdQuery query) {
var dbResult = dbContext.ProductNames.FirstOrDefault(x => x.ProductNameID == query.ProductId);
if(dbResult == null) {
return new Models.DomainModel.ProductName();
}
return new Models.DomainModel.ProductName {
ProductId = dbResult.ProductNameID,
Name = dbResult.Name
};
}
