public void Save(SaveStoreData request)
{
var aggregateFilter = Builders <AggregateDocument> .Filter.Eq("_id", request.AggregateRootId.ToString());
var aggregateDocument = _dbContext.Aggregates.Find(aggregateFilter).FirstOrDefault();
if (aggregateDocument == null)
{
var newAggregateDocument = _aggregateDocumentFactory.CreateAggregate(request.AggregateType, request.AggregateRootId);
_dbContext.Aggregates.InsertOne(newAggregateDocument);
}
if (request.DomainCommand != null)
{
var commandDocument = _commandDocumentFactory.CreateCommand(request.DomainCommand);
_dbContext.Commands.InsertOne(commandDocument);
}
foreach (var @event in request.Events)
{
var eventFilter = Builders <EventDocument> .Filter.Eq("aggregateId", @event.AggregateRootId.ToString());
var currentVersion = _dbContext.Events.Find(eventFilter).CountDocuments();
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, (int)currentVersion, request.DomainCommand?.ExpectedVersion);
var eventDocument = _eventDocumentFactory.CreateEvent(@event, nextVersion);
_dbContext.Events.InsertOne(eventDocument);
}
}
public async Task SaveAsync(SaveStoreData request)
{
var aggregateDocument = await _aggregateRepository.GetDocumentAsync(request.AggregateRootId.ToString());
if (aggregateDocument == null)
{
var newAggregateDocument = _aggregateDocumentFactory.CreateAggregate(request.AggregateType, request.AggregateRootId);
await _aggregateRepository.CreateDocumentAsync(newAggregateDocument);
}
if (request.DomainCommand != null)
{
var commandDocument = _commandDocumentFactory.CreateCommand(request.DomainCommand);
await _commandRepository.CreateDocumentAsync(commandDocument);
}
foreach (var @event in request.Events)
{
var currentVersion = await _eventRepository.GetCountAsync(d => d.AggregateId == @event.AggregateRootId);
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, currentVersion, request.DomainCommand?.ExpectedVersion);
var eventDocument = _eventDocumentFactory.CreateEvent(@event, nextVersion);
await _eventRepository.CreateDocumentAsync(eventDocument);
}
}
public void Save(SaveStoreData request)
{
var aggregateDocument = _aggregateRepository.GetDocumentAsync(request.AggregateRootId.ToString(), request.AggregateType.AssemblyQualifiedName).GetAwaiter().GetResult();
if (aggregateDocument == null)
{
var newAggregateDocument = _aggregateDocumentFactory.CreateAggregate(request.AggregateType, request.AggregateRootId);
_aggregateRepository.CreateDocumentAsync(newAggregateDocument, request.AggregateType.AssemblyQualifiedName).GetAwaiter().GetResult();
}
if (request.DomainCommand != null)
{
var commandDocument = _commandDocumentFactory.CreateCommand(request.DomainCommand);
_commandRepository.CreateDocumentAsync(commandDocument, request.DomainCommand.GetType().AssemblyQualifiedName).GetAwaiter().GetResult();
}
foreach (var @event in request.Events)
{
var currentVersion = _eventRepository.GetCountAsync(d => d.AggregateId == @event.AggregateRootId).GetAwaiter().GetResult();
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, currentVersion, request.DomainCommand?.ExpectedVersion);
var eventDocument = _eventDocumentFactory.CreateEvent(@event, nextVersion);
_eventRepository.CreateDocumentAsync(eventDocument, @event.GetType().AssemblyQualifiedName).GetAwaiter().GetResult();
}
}
public void Save(SaveStoreData request)
{
using (var dbContext = _dbContextFactory.CreateDbContext())
{
var aggregateEntity = dbContext.Aggregates.FirstOrDefault(x => x.Id == request.AggregateRootId);
if (aggregateEntity == null)
{
var newAggregateEntity = _aggregateEntityFactory.CreateAggregate(request.AggregateType, request.AggregateRootId);
dbContext.Aggregates.Add(newAggregateEntity);
}
if (request.DomainCommand != null)
{
var newCommandEntity = _commandEntityFactory.CreateCommand(request.DomainCommand);
dbContext.Commands.Add(newCommandEntity);
}
foreach (var @event in request.Events)
{
var currentVersion = dbContext.Events.Count(x => x.AggregateId == @event.AggregateRootId);
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, currentVersion, request.DomainCommand?.ExpectedVersion);
var newEventEntity = _eventEntityFactory.CreateEvent(@event, nextVersion);
dbContext.Events.Add(newEventEntity);
}
dbContext.SaveChanges();
}
}
public void SetUp()
{
_createSomething = new CreateSomething();
_createSomethingConcrete = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_createAggregateConcrete = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_sampleCommandSequence = new SampleCommandSequence();
_commandInSequenceConcrete = new CommandInSequence();
_commandResponse = new CommandResponse {
Events = _events, Result = "Result"
};
_domainCommandResponse = new CommandResponse {
Events = _aggregate.Events, Result = "Result"
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.PublishAsync(_aggregateCreatedConcrete))
.Returns(Task.CompletedTask);
_storeProvider = new Mock <IStoreProvider>();
_storeProvider
.Setup(x => x.SaveAsync(It.IsAny <SaveStoreData>()))
.Callback <SaveStoreData>(x => _storeDataSaved = x)
.Returns(Task.CompletedTask);
_objectFactory = new Mock <IObjectFactory>();
_objectFactory
.Setup(x => x.CreateConcreteObject(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(_createSomething))
.Returns(_createSomethingConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(_createAggregate))
.Returns(_createAggregateConcrete);
_objectFactory
.Setup(x => x.CreateConcreteObject(It.IsAny <CommandInSequence>()))
.Returns(_commandInSequenceConcrete);
_validationService = new Mock <IValidationService>();
_validationService
.Setup(x => x.ValidateAsync(It.IsAny <CreateSomething>()))
.Returns(Task.CompletedTask);
_commandHandlerAsync = new Mock <ICommandHandlerAsync <CreateSomething> >();
_commandHandlerAsync
.Setup(x => x.HandleAsync(_createSomethingConcrete))
.ReturnsAsync(_commandResponse);
_domainCommandHandlerAsync = new Mock <ICommandHandlerAsync <CreateAggregate> >();
_domainCommandHandlerAsync
.Setup(x => x.HandleAsync(_createAggregate))
.ReturnsAsync(_domainCommandResponse);
_domainCommandHandlerAsync
.Setup(x => x.HandleAsync(_createAggregateConcrete))
.ReturnsAsync(_domainCommandResponse);
_sequenceCommandHandlerAsync = new Mock <ISequenceCommandHandlerAsync <CommandInSequence> >();
_sequenceCommandHandlerAsync
.Setup(x => x.HandleAsync(It.IsAny <CommandInSequence>(), It.IsAny <CommandResponse>()))
.ReturnsAsync(_commandResponse);
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateSomething> >())
.Returns(_commandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <ICommandHandlerAsync <CreateAggregate> >())
.Returns(_domainCommandHandlerAsync.Object);
_handlerResolver
.Setup(x => x.ResolveHandler <ISequenceCommandHandlerAsync <CommandInSequence> >())
.Returns(_sequenceCommandHandlerAsync.Object);
_mainOptionsMock = new Mock <IOptions <MainOptions> >();
_mainOptionsMock
.Setup(x => x.Value)
.Returns(new MainOptions());
_validationOptionsMock = new Mock <IOptions <ValidationOptions> >();
_validationOptionsMock
.Setup(x => x.Value)
.Returns(new ValidationOptions());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_objectFactory.Object,
_storeProvider.Object,
_validationService.Object,
_mainOptionsMock.Object,
_validationOptionsMock.Object);
}
public void SetUp()
{
_createSomething = new CreateSomething();
_somethingCreated = new SomethingCreated();
_somethingCreatedConcrete = new SomethingCreated();
_events = new List <IEvent> {
_somethingCreated
};
_createAggregate = new CreateAggregate();
_aggregateCreatedConcrete = new AggregateCreated();
_aggregate = new Aggregate();
_aggregateCreated = (AggregateCreated)_aggregate.Events[0];
_sampleCommandSequence = new sampleCommandSequence();
_commandResponse = new CommandResponse {
Events = _events, Result = "Result"
};
_domainCommandResponse = new CommandResponse {
Events = _aggregate.Events, Result = "Result"
};
_eventPublisher = new Mock <IEventPublisher>();
_eventPublisher
.Setup(x => x.Publish(_aggregateCreatedConcrete));
_storeProvider = new Mock <IStoreProvider>();
_storeProvider
.Setup(x => x.Save(It.IsAny <SaveStoreData>()))
.Callback <SaveStoreData>(x => _storeDataSaved = x);
_eventFactory = new Mock <IEventFactory>();
_eventFactory
.Setup(x => x.CreateConcreteEvent(_somethingCreated))
.Returns(_somethingCreatedConcrete);
_eventFactory
.Setup(x => x.CreateConcreteEvent(_aggregateCreated))
.Returns(_aggregateCreatedConcrete);
_validationService = new Mock <IValidationService>();
_validationService
.Setup(x => x.Validate(_createAggregate));
_commandHandler = new Mock <ICommandHandler <CreateSomething> >();
_commandHandler
.Setup(x => x.Handle(_createSomething))
.Returns(_commandResponse);
_domainCommandHandler = new Mock <ICommandHandler <CreateAggregate> >();
_domainCommandHandler
.Setup(x => x.Handle(_createAggregate))
.Returns(_domainCommandResponse);
_sequenceCommandHandler = new Mock <ISequenceCommandHandler <ICommand> >();
_sequenceCommandHandler
.Setup(x => x.Handle(It.IsAny <ICommand>(), It.IsAny <CommandResponse>()))
.Returns(It.IsAny <CommandResponse>());
_handlerResolver = new Mock <IHandlerResolver>();
_handlerResolver
.Setup(x => x.ResolveHandler(_createSomething, typeof(ICommandHandler <>)))
.Returns(_commandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(_createAggregate, typeof(ICommandHandler <>)))
.Returns(_domainCommandHandler.Object);
_handlerResolver
.Setup(x => x.ResolveHandler(It.IsAny <ICommand>(), typeof(ISequenceCommandHandler <>)))
.Returns(_sequenceCommandHandler.Object);
_optionsMock = new Mock <IOptions <Options> >();
_optionsMock
.Setup(x => x.Value)
.Returns(new Options());
_sut = new CommandSender(_handlerResolver.Object,
_eventPublisher.Object,
_eventFactory.Object,
_storeProvider.Object,
_validationService.Object,
_optionsMock.Object);
}
