public List<DomainEvent> EventsForAggregate(AggregateKey key)
{
List<DomainEvent> eventsForAggregate = new List<DomainEvent>();
var streamName = _aggregateIdToStreamName(key.AggregateType, key.AggregateId);
StreamEventsSlice currentSlice;
var nextSliceStart = 0;
do
{
currentSlice = _eventStoreConnection
.ReadStreamEventsForwardAsync(streamName, nextSliceStart, ReadPageSize, false)
.Result;
nextSliceStart = currentSlice.NextEventNumber;
foreach (var evnt in currentSlice.Events)
{
DomainEvent aggrEvent = (DomainEvent)DeserializeEvent(evnt.OriginalEvent.Metadata, evnt.OriginalEvent.Data);
eventsForAggregate.Add(aggrEvent);
}
} while (!currentSlice.IsEndOfStream);
return eventsForAggregate;
}
/// <summary>
/// Collects all processed events for given aggregate and return them as a list
/// used to build up an aggregate from its history (Domain.ReconstituteFromHistory)
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public List<DomainEvent> EventsForAggregate(AggregateKey key)
{
List<EventDescriptor> eventDescriptors;
if (!_current.TryGetValue(key.AggregateId, out eventDescriptors))
{
throw new AggregateNotFoundException();
}
return eventDescriptors.Select(desc => desc.EventData).ToList();
}
public List<DomainEvent> EventsForAggregate(AggregateKey key)
{
List<DomainEvent> eventsForAggregate = new List<DomainEvent>();
var streamName = _aggregateIdToStreamName(key.AggregateType, key.AggregateId);
using (ISession session = this.factory.OpenSession())
using (ITransaction tx = session.BeginTransaction())
{
var events = session
.QueryOver<RecordedEvent>()
.Where(e => e.EventStreamId == streamName)
.OrderBy(e => e.EventNumber).Asc
.Future();
foreach (var evnt in events)
{
DomainEvent aggrEvent = (DomainEvent)DeserializeEvent(evnt.Metadata, evnt.Data);
eventsForAggregate.Add(aggrEvent);
}
}
return eventsForAggregate;
}
/// <summary>
/// Saves the events for an aggregate that might be unknown to the system.
/// </summary>
/// <param name="key"></param>
/// <param name="expectedRevision"></param>
/// <param name="events"></param>
public void SaveEvents(AggregateKey key, int expectedRevision, IEnumerable<DomainEvent> events)
{
List<EventDescriptor> eventDescriptors;
// try to get event descriptors list for given aggregate id
// otherwise -> create empty dictionary
if (!_current.TryGetValue(key.AggregateId, out eventDescriptors))
{
eventDescriptors = new List<EventDescriptor>();
_current.Add(key.AggregateId, eventDescriptors);
}
// check whether latest event version matches current aggregate version
// otherwise -> throw exception
else if (eventDescriptors[eventDescriptors.Count - 1].Revision != expectedRevision && expectedRevision != -1)
{
throw new ConcurrencyException();
}
var i = expectedRevision;
// iterate through current aggregate events increasing version with each processed event
foreach (var @event in events)
{
i++;
// @event.Version = i;
// push event to the event descriptors list for current aggregate
eventDescriptors.Add(new EventDescriptor(key.AggregateId, @event, i));
// publish current event to the bus for further processing by subscribers
_publisher.Publish(@event as Event);
}
}
public void SaveEvents(AggregateKey key, int expectedRevision, IEnumerable<DomainEvent> events)
{
var commitHeaders = new Dictionary<string, object>
{
{CommitIdHeader, Guid.NewGuid()},
{AggregateClrTypeHeader, key.AggregateType.AssemblyQualifiedName}
};
// updateHeaders(commitHeaders);
var streamName = _aggregateIdToStreamName(key.AggregateType, key.AggregateId);
var newEvents = events.Cast<object>().ToList();
var eventNumber = expectedRevision;
var preparedEvents = PrepareEvents(newEvents, commitHeaders).ToList();
using (ISession session = this.factory.OpenSession())
using (ITransaction tx = session.BeginTransaction())
{
foreach (var uncommittedEvent in preparedEvents)
{
var entry = new RecordedEvent()
{
Created = DateTime.UtcNow,
CreatedEpoch = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds,
Data = uncommittedEvent.Data,
EventId = uncommittedEvent.EventId,
EventStreamId = streamName,
IsJson = uncommittedEvent.IsJson,
EventType = uncommittedEvent.Type,
Metadata = uncommittedEvent.Metadata,
EventNumber = eventNumber
};
session.Save(entry);
eventNumber += 1;
}
tx.Commit();
}
foreach (var @event in events)
{
_publisher.Publish(@event);
}
}
public void SaveEvents(AggregateKey key, int expectedRevision, IEnumerable<DomainEvent> uncommittedEvents)
{
var commitHeaders = new Dictionary<string, object>
{
{CommitIdHeader, Guid.NewGuid()},
{AggregateClrTypeHeader, key.AggregateType.AssemblyQualifiedName}
};
var streamName = _aggregateIdToStreamName(key.AggregateType, key.AggregateId);
var newEvents = uncommittedEvents.Cast<object>().ToList();
var expectedVersion = expectedRevision <= 0 ? ExpectedVersion.NoStream : expectedRevision - 1;
expectedVersion = ExpectedVersion.Any;
var preparedEvents = PrepareEvents(newEvents, commitHeaders).ToList();
if (preparedEvents.Count < WritePageSize)
{
_eventStoreConnection
.AppendToStreamAsync(streamName, expectedVersion, preparedEvents)
.Wait();
}
else
{
var transaction = _eventStoreConnection
.StartTransactionAsync(streamName, expectedVersion)
.Result;
var position = 0;
while (position < preparedEvents.Count)
{
var pageEvents = preparedEvents.Skip(position).Take(WritePageSize);
transaction.WriteAsync(pageEvents).Wait();
position += WritePageSize;
}
transaction.CommitAsync().Wait();
}
foreach (var @event in uncommittedEvents)
{
_publisher.Publish(@event);
}
}
