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 void Save(SaveStoreData request)
{
var aggregateDocument = _aggregateRepository.GetDocumentAsync(request.AggregateRootId.ToString()).GetAwaiter().GetResult();
if (aggregateDocument == null)
{
var newAggregateDocument = _aggregateDocumentFactory.CreateAggregate(request.AggregateType, request.AggregateRootId);
_aggregateRepository.CreateDocumentAsync(newAggregateDocument).GetAwaiter().GetResult();
}
if (request.DomainCommand != null)
{
var commandDocument = _commandDocumentFactory.CreateCommand(request.DomainCommand);
_commandRepository.CreateDocumentAsync(commandDocument).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).GetAwaiter().GetResult();
}
}
public void Save(Type aggregateType, Guid aggregateRootId, IDomainCommand command, IEnumerable <IDomainEvent> events)
{
var aggregateDocument = _aggregateRepository.GetDocumentAsync(aggregateRootId.ToString()).GetAwaiter().GetResult();
if (aggregateDocument == null)
{
var newAggregateDocument = _aggregateDocumentFactory.CreateAggregate(aggregateType, aggregateRootId);
_aggregateRepository.CreateDocumentAsync(newAggregateDocument).GetAwaiter().GetResult();
}
if (command != null)
{
var commandDocument = _commandDocumentFactory.CreateCommand(command);
_commandRepository.CreateDocumentAsync(commandDocument).GetAwaiter().GetResult();
}
foreach (var @event in events)
{
var currentVersion = _eventRepository.GetCountAsync(d => d.AggregateId == @event.AggregateRootId).GetAwaiter().GetResult();
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, currentVersion, command?.ExpectedVersion);
var eventDocument = _eventDocumentFactory.CreateEvent(@event, nextVersion);
_eventRepository.CreateDocumentAsync(eventDocument).GetAwaiter().GetResult();
}
}
public void Save(Type aggregateType, Guid aggregateRootId, IDomainCommand command, IEnumerable <IDomainEvent> events)
{
using (var dbContext = _dbContextFactory.CreateDbContext())
{
var aggregateEntity = dbContext.Aggregates.FirstOrDefault(x => x.Id == aggregateRootId);
if (aggregateEntity == null)
{
var newAggregateEntity = _aggregateEntityFactory.CreateAggregate(aggregateType, aggregateRootId);
dbContext.Aggregates.Add(newAggregateEntity);
}
if (command != null)
{
var newCommandEntity = _commandEntityFactory.CreateCommand(command);
dbContext.Commands.Add(newCommandEntity);
}
foreach (var @event in events)
{
var currentVersion = dbContext.Events.Count(x => x.AggregateId == @event.AggregateRootId);
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, currentVersion, command?.ExpectedVersion);
var newEventEntity = _eventEntityFactory.CreateEvent(@event, nextVersion);
dbContext.Events.Add(newEventEntity);
}
dbContext.SaveChanges();
}
}
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();
}
}
/// <inheritdoc />
public async Task SaveEventAsync <TAggregate>(IDomainEvent @event, int?expectedVersion) where TAggregate : IAggregateRoot
{
var currentVersion = await _eventRepository.GetCountAsync(d => d.AggregateId == @event.AggregateRootId);
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, currentVersion, expectedVersion);
var eventDocument = _eventDocumentFactory.CreateEvent(@event, nextVersion);
await _eventRepository.CreateDocumentAsync(eventDocument);
}
/// <inheritdoc />
public async Task SaveEventAsync <TAggregate>(IDomainEvent @event, int?expectedVersion) where TAggregate : IAggregateRoot
{
var eventFilter = Builders <EventDocument> .Filter.Eq("aggregateId", @event.AggregateRootId.ToString());
var currentVersion = await _dbContext.Events.Find(eventFilter).CountDocumentsAsync();
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, (int)currentVersion, expectedVersion);
var eventDocument = _eventDocumentFactory.CreateEvent(@event, nextVersion);
await _dbContext.Events.InsertOneAsync(eventDocument);
}
/// <inheritdoc />
public async Task SaveEventAsync <TAggregate>(IDomainEvent @event, int?expectedVersion) where TAggregate : IAggregateRoot
{
using (var dbContext = _dbContextFactory.CreateDbContext())
{
var currentVersion = await dbContext.Events.CountAsync(x => x.AggregateId == @event.AggregateRootId);
var nextVersion = _versionService.GetNextVersion(@event.AggregateRootId, currentVersion, expectedVersion);
var newEventEntity = _eventEntityFactory.CreateEvent(@event, nextVersion);
await dbContext.Events.AddAsync(newEventEntity);
await dbContext.SaveChangesAsync();
}
}
public async Task SaveEventAsync <TAggregate>(IDomainEvent @event, int?expectedVersion = null) where TAggregate : IAggregateRoot
{
await Task.CompletedTask;
EnsureAggregateExists <TAggregate>(@event.AggregateRootId);
var currentVersion = Events.Where(x => x.AggregateId == @event.AggregateRootId).Count();
var nextVersion = VersionService.GetNextVersion(@event.AggregateRootId, currentVersion, expectedVersion);
var eventDocument = new EventDocument()
{
Id = @event.Id,
AggregateId = @event.AggregateRootId,
CommandId = @event.CommandId,
Sequence = nextVersion,
Type = @event.GetType().AssemblyQualifiedName,
Data = JsonConvert.SerializeObject(@event),
TimeStamp = @event.TimeStamp,
UserId = @event.UserId,
Source = @event.Source
};
Events.Add(eventDocument);
}
