public async Task <Result> AddData(AddDataCommand command)
{
EnsureArg.IsNotNull(command);
var userResult = await userService.GetByUsername(command.Username)
.ToResult("User not found");
userResult = await userResult.OnFailureCompensate(
() => command.FileType == FileType.Input
?userService.AddUser(new AddUserCommand(command.Username))
: Task.FromResult(userResult));
var userModels = await dataFileReadRepository.Find(file =>
file.User.Username == command.Username && file.FileType == FileType.Model);
return(await userResult
.Bind(u => DataFile.Create(command.Filename, u, command.FileType))
.Tap(df =>
{
if (command.FileType == FileType.Input && userModels.Any())
{
df.AddDomainEvent(new NewAccelerometerDataEvent(command.Username, command.Email));
}
})
.Tap(df =>
{
var saveFileCommand = new SaveFileCommand(command.ContentStream, command.Filename, command.Username,
df.Id);
fileStorageService.SaveFile(saveFileCommand);
})
.Tap(df => dataFileWriteRepository.Create(df))
.Tap(() => dataFileWriteRepository.Commit()));
}
/// <summary>
/// Retrieves the result for the specified query.
/// </summary>
/// <param name="query">The query.</param>
/// <returns>The query result.</returns>
public IEnumerable <TModel> Retrieve(FindQuery <TModel> query)
{
var entities = _repository.Find(query.Filter);
var model = _mapper.Map <IEnumerable <TModel> >(entities);
return(model);
}
public Task <GetWaitingStepQueryResponse> Handle(GetWaitingStepQuery request, CancellationToken cancellationToken)
{
// Build retrieval
var buildPersistenceModel = _buildRepository.Find(request.BuildID);
if (buildPersistenceModel == null)
{
throw new ArgumentException($"Build with id \"{request.BuildID}\" does not exist.");
}
// Conversion
var buildDomainEntity = _mapper.Map <BuildDomainEntity>(buildPersistenceModel);
// Retrieval via business logic
var buildStepContainer = buildDomainEntity.GetNextWaitingStep();
if (buildStepContainer == null)
{
return(Task.FromResult <GetWaitingStepQueryResponse>(null));
}
// Conversion to application model
var stepPersistenceModel = _mapper.Map <BuildStepPersistenceModel>(buildStepContainer.Step);
var stepApplicationModel = _mapper.Map <BuildStepApplicationModel>(stepPersistenceModel);
return(Task.FromResult(new GetWaitingStepQueryResponse(stepApplicationModel, buildStepContainer.Index)));
}
public Task <BuildApplicationModel> Handle(GetBuildQuery request, CancellationToken cancellationToken)
{
var buildPersistenceModel = _buildRepository.Find(request.ID);
if (buildPersistenceModel == null)
{
return(Task.FromResult <BuildApplicationModel>(null));
}
var buildApplicationModel = _mapper.Map <BuildApplicationModel>(buildPersistenceModel);
return(Task.FromResult(buildApplicationModel));
}
public static TEntity Resolve <TEntity>([NotNull] this TEntity entity, [NotNull] IReadRepository <TEntity> repository)
where TEntity : class, IEntity
{
if (entity.Id == Entity.NoId)
{
return(entity);
}
var entityWithResolvedRefs = repository.Find(entity.Id);
if (entityWithResolvedRefs == null)
{
throw new KeyNotFoundException($"{entity.GetType().Name} with ID {entity.Id} not found.");
}
return(entityWithResolvedRefs);
}
public DescriptiveResponse <FilteredCollection <TRead> > FilterCollection(Filtration filter)
{
try
{
// Add userId in case of entity of type managed entity
if (typeof(TRead).IsSubclassOf(typeof(ManagedEntity <TId, TUId>)))
{
if (filter == null)
{
filter = new Filtration();
}
if (filter.SearchCriteria == null)
{
filter.SearchCriteria = new List <FilterSearchCriteria>();
}
filter.SearchCriteria.Add(new FilterSearchCriteria
{
Field = "CreatedBy",
Operator = LogicalOperator.Equal,
SearchKey = UserUtility <TUId> .CurrentUser.UserId.ToString()
});
}
// Find all items that match filteration
FilteredCollection <TRead> filteredCollection = _readRepository.Find(filter);
// Return success response
return(DescriptiveResponse <FilteredCollection <TRead> > .Success(filteredCollection));
}
catch (Exception ex)
{
// Log error
Logger.Log(ex);
// return unexpected error
return(DescriptiveResponse <FilteredCollection <TRead> > .Error(ErrorStatus.UNEXPECTED_ERROR));
}
}
public TEntity Find(long id) => Inner.Find(id)?.DehydrateReferences();
public async Task Handle(WorkItemReassignedEvent evnt)
{
var workItem = await repository.Find(evnt.AggregateId);
workItem.BrokerId = evnt.BrokerId;
}
public virtual TEntity Read(long id)
{
return(CheckFound(Repository.Find(id), id));
}
public bool BuildExistsByID(string buildID)
{
return(_buildRepository.Find(buildID) != null);
}
