private void PersistEvents(EventStoreStream eventStoreStream)
{
var collection = GetMongoDbCollection(EventCollection);
var events = eventStoreStream.Events
.Select(@event =>
{
var timestamp = DateTime.Now;
@event.Timestamp = timestamp;
var id = new ObjectId(timestamp, 1, 1, ++version);
return(new EventPersistance
{
Id = id,
Version = version, // id.Increment,
Timestamp = timestamp,
AggregateId = eventStoreStream.Id.ToString(),
EventClass = @event.GetType().AssemblyQualifiedName,
Data = JsonConvert.SerializeObject(@event)
});
})
.ToList();
collection.InsertMany(events);
// TODO handle potential failures
}
public override async Task <IEventStoreStream> ReadEventsAsync(string eventStreamId, int fromRevision, int toRevision)
{
lock (EventStreamsSync)
{
bool streamExists = this.StreamExistsAsync(eventStreamId).Result;
if (!streamExists)
{
throw new EventStreamNotFoundException($"No Event Stream was found for ID '{eventStreamId}' and expected revision '{toRevision}'. Either the stream did not exist at all or the stream existed but did not match the expected revision.");
}
IList <EventStoreMessage> eventStoreMessages = EventStreams[eventStreamId];
if (toRevision == ExpectedStreamRevision.End)
{
toRevision = eventStoreMessages.Count;
}
if (toRevision < 0)
{
throw new ArgumentException(
$"The value must specify the revision of the stream or the end of the stream ('{ExpectedStreamRevision.End}').",
nameof(toRevision));
}
IEventStoreStream eventStoreStream = new EventStoreStream(toRevision);
for (int i = fromRevision; i < toRevision; i++)
{
eventStoreStream.Add(eventStoreMessages[i]);
this.logger.Info($"Read message of type '{eventStoreMessages[i].Body.GetType().Name}' from stream '{eventStreamId}'.");
}
return(eventStoreStream);
}
}
private void PersistEvents(EventStoreStream eventStoreStream)
{
if (_store.ContainsKey(eventStoreStream.Id))
{
_store[eventStoreStream.Id].AddRange(eventStoreStream.Events);
}
else
{
_store.Add(eventStoreStream.Id, eventStoreStream.Events);
}
}
protected void Given <TEventStream, TEvent>(Guid id, TEvent evt)
where TEvent : IEvent
where TEventStream : EventStream
{
var streamIdentifier = new StreamIdentifier(typeof(TEventStream).Name, id);
var eventStoreStream = new EventStoreStream(streamIdentifier, new List <IEvent> {
evt
});
this.eventStore.Save(new List <EventStoreStream> {
eventStoreStream
});
this.eventStore.CommitInitialEvents();
}
public Task SaveAsync(EventStoreStream eventStoreStream)
{
if (_store.TryAdd(eventStoreStream.Id.Value, eventStoreStream.Events))
{
return(Task.FromResult(0));
}
if (_store.TryGetValue(eventStoreStream.Id.Value, out var value))
{
var currentEvents = value
.Concat(eventStoreStream.Events);
if (_store.TryUpdate(eventStoreStream.Id.Value, currentEvents.ToList(), value))
{
return(Task.FromResult(0));
}
}
throw new InvalidOperationException("Persisting events failed.");
}
private void PersistEvents(EventStoreStream eventStoreStream)
{
var eventList = new List <IEvent>();
foreach (var @event in eventStoreStream.Events)
{
@event.Version = ++version;
@event.Timestamp = DateTime.Now;
eventList.Add(@event);
}
if (!store.ContainsKey(eventStoreStream.Id))
{
store.Add(eventStoreStream.Id, eventList);
}
else
{
store[eventStoreStream.Id].AddRange(eventList);
}
}