public void Should_not_add_event_to_uncommitted_events_and_increase_version_when_raised()
{
var event1 = new MyEvent();
var event2 = new MyEvent();
var sut = new DO(Guid.NewGuid(), 10);
IAggregate aggregate = sut;
aggregate.ApplyEvent(new Envelope <IEvent>(event1));
aggregate.ApplyEvent(new Envelope <IEvent>(event2));
Assert.Equal(12, sut.Version);
Assert.Equal(0, sut.GetUncomittedEvents().Count);
}
public static void LoadsFromHistory(this IAggregate aggregate, IEnumerable <IEvent> history)
{
foreach (var @event in history)
{
aggregate.ApplyEvent(@event);
}
}
public static void ApplyEvents(this IAggregate aggregate, params DomainEvent[] events)
{
foreach (var e in events)
{
aggregate.ApplyEvent(e);
}
}
public async Task LoadAsync(IAggregate domainObject, long?expectedVersion = null)
{
var streamName = nameResolver.GetStreamName(domainObject.GetType(), domainObject.Id);
var events = await eventStore.GetEventsAsync(streamName);
if (events.Count == 0)
{
throw new DomainObjectNotFoundException(domainObject.Id.ToString(), domainObject.GetType());
}
foreach (var storedEvent in events)
{
var envelope = ParseKnownCommand(storedEvent);
if (envelope != null)
{
domainObject.ApplyEvent(envelope);
}
}
if (expectedVersion != null && domainObject.Version != expectedVersion.Value)
{
throw new DomainObjectVersionException(domainObject.Id.ToString(), domainObject.GetType(), domainObject.Version, expectedVersion.Value);
}
}
private static void ApplyEventsToAggregate(int versionToLoad, IEventStream stream, IAggregate aggregate)
{
if (versionToLoad == 0 || aggregate.Version < versionToLoad)
{
foreach (var @event in stream.CommittedEvents.Select(x => x.Body))
{
aggregate.ApplyEvent(@event);
}
}
}
public EventSourcedActor(IConstructAggregates aggregateConstructor,
ISnapshotsPersistencePolicy policy,
IPublisher publisher)
{
PersistenceId = Self.Path.Name;
SnapshotsPolicy = policy;
_aggregateConstructor = aggregateConstructor;
Publisher = publisher;
Id = AggregateActorName.Parse <T>(Self.Path.Name).Id;
State = (AggregateBase)aggregateConstructor.Build(typeof(T), Id, null);
Monitor = new ActorMonitor(Context, typeof(T).Name);
Command <GracefullShutdownRequest>(req =>
{
Monitor.IncrementMessagesReceived();
DeleteSnapshots(SnapshotsPolicy.GetSnapshotsToDelete());
Become(Terminating);
});
Command <CheckHealth>(s => Sender.Tell(new HealthStatus(s.Payload)));
Command <SaveSnapshotSuccess>(s =>
{
NotifyWatchers(s);
SnapshotsPolicy.MarkSnapshotSaved(s.Metadata);
});
Command <NotifyOnPersistenceEvents>(c =>
{
var waiter = c.Waiter ?? Sender;
if (IsRecoveryFinished)
{
waiter.Tell(RecoveryCompleted.Instance);
}
_persistenceWaiters.Add(waiter);
});
Recover <DomainEvent>(e =>
{
State.ApplyEvent(e);
SnapshotsPolicy.MarkActivity(e.CreatedTime);
});
Recover <SnapshotOffer>(offer =>
{
SnapshotsPolicy.MarkSnapshotApplied(offer.Metadata);
State = _aggregateConstructor.Build(typeof(T), Id, (IMemento)offer.Snapshot);
});
Recover <RecoveryCompleted>(message =>
{
_log.Debug("Recovery for actor {Id} is completed", PersistenceId);
NotifyWatchers(message);
});
}
private static void ApplyEventsToAggregate(int versionToLoad, IEventStream stream, IAggregate aggregate)
{
if (versionToLoad == 0 || aggregate.Version < versionToLoad)
{
// This is where we need to filter out any null events.
foreach (var @event in stream.CommittedEvents.Where(e => e != null).Select(x => x.Body))
{
aggregate.ApplyEvent(@event);
}
}
}
private static void ApplyEventsToAggregate(int versionToLoad, IEventStream stream, IAggregate aggregate)
{
if (versionToLoad != 0 && aggregate.Version >= versionToLoad)
{
return;
}
foreach (object @event in stream.CommittedEvents.Select(x => x.Body))
{
aggregate.ApplyEvent(@event);
}
}
public IAggregate TryGetById(string streamName)
{
EnsureConnected();
IAggregate aggregate = BuildAggregate(streamName);
StreamEventsSlice currentSlice;
var nextSliceStart = 0;
do
{
currentSlice = _eventStoreConnection.ReadStreamEventsForward(streamName, nextSliceStart, ReadPageSize, true);
nextSliceStart = currentSlice.NextEventNumber;
foreach (var evnt in currentSlice.Events)
{
aggregate.ApplyEvent(DeserializeEvent(evnt.Event.Metadata, evnt.Event.Data));
}
} while (!currentSlice.IsEndOfStream);
return(aggregate);
}
private void ApplyEvent <TEvent>(IAggregate aggregate, TEvent @event)
{
aggregate.ApplyEvent(@event);
}