protected virtual void OnEventApplied(UncommittedEvent evnt)
{
if (EventApplied != null)
{
EventApplied(this, new EventAppliedEventArgs(evnt));
}
}
protected CommandTestFixture()
{
var commandExecutor = BuildCommandExecutor();
PublishedEvents = new UncommittedEvent[0];
SetupDependencies();
try
{
var command = WhenExecutingCommand();
using (var context = new EventContext())
{
commandExecutor.Execute(command);
ExecutedCommand = command;
PublishedEvents = context.Events;
}
}
catch (Exception exception)
{
CaughtException = exception;
}
finally
{
Finally();
}
}
/// <inheritdoc/>
public async Task <IProjectionResult> Project(ProjectionCurrentState state, UncommittedEvent @event, ExecutionContext executionContext, CancellationToken cancellationToken)
{
try
{
_logger.ProjectEventThroughDispatcher(_embeddingId, state);
var response = await _dispatcher.Call(
_requestFactory.Create(state, @event),
executionContext,
cancellationToken).ConfigureAwait(false);
if (IsFailureResponse(response))
{
return(new ProjectionFailedResult(GetFailureReason(response)));
}
return(response.ResponseCase switch
{
EmbeddingResponse.ResponseOneofCase.ProjectionDelete => new ProjectionDeleteResult(),
EmbeddingResponse.ResponseOneofCase.ProjectionReplace => new ProjectionReplaceResult(response.ProjectionReplace.State),
EmbeddingResponse.ResponseOneofCase.Compare
=> new ProjectionFailedResult(new UnexpectedEmbeddingResponse(_embeddingId, response.ResponseCase)),
EmbeddingResponse.ResponseOneofCase.Delete
=> new ProjectionFailedResult(new UnexpectedEmbeddingResponse(_embeddingId, response.ResponseCase)),
_ => new ProjectionFailedResult(new UnexpectedEmbeddingResponse(_embeddingId, response.ResponseCase))
});
}
Task InsertEvent(
IClientSessionHandle transaction,
EventLogSequenceNumber version,
DateTimeOffset occurred,
EventSourceId eventSource,
UncommittedEvent @event,
AggregateMetadata aggregate,
Execution.ExecutionContext executionContext,
CancellationToken cancellationToken)
{
return(_streams.DefaultEventLog.InsertOneAsync(
transaction,
new Event(
version,
executionContext.ToStoreRepresentation(),
new EventMetadata(
occurred.UtcDateTime,
eventSource,
@event.Type.Id,
@event.Type.Generation,
@event.Public),
aggregate,
new EventHorizonMetadata(),
BsonDocument.Parse(@event.Content)),
cancellationToken: cancellationToken));
}
/// <summary>Saves the event to the data store.</summary>
/// <param name="uncommittedEvent">The event to save.</param>
/// <param name="transaction">The transaction.</param>
private void SaveEvent(UncommittedEvent uncommittedEvent, SqlTransaction transaction)
{
Contract.Requires <ArgumentNullException>(uncommittedEvent != null, "The argument uncommittedEvent could not be null.");
Contract.Requires <ArgumentNullException>(transaction != null, "The argument transaction could not be null.");
string eventName;
var document = _formatter.Serialize(uncommittedEvent.Payload, out eventName);
var storedEvent = new StoredEvent <JObject>(uncommittedEvent.EventIdentifier, uncommittedEvent.EventTimeStamp,
eventName, uncommittedEvent.EventVersion, uncommittedEvent.EventSourceId,
uncommittedEvent.EventSequence, document);
var raw = _translator.TranslateToRaw(storedEvent);
using (var command = new SqlCommand(Queries.InsertNewEventQuery, transaction.Connection))
{
command.Transaction = transaction;
command.Parameters.AddWithValue("EventId", raw.EventIdentifier);
command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp);
command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId);
command.Parameters.AddWithValue("Name", raw.EventName);
command.Parameters.AddWithValue("Version", raw.EventVersion.ToString());
command.Parameters.AddWithValue("Sequence", raw.EventSequence);
command.Parameters.AddWithValue("Data", raw.Data);
command.ExecuteNonQuery();
}
}
private static bool AreEqual(UncommittedEvent uncommitted, CommittedEvent committed)
{
return(uncommitted.EventIdentifier == committed.EventIdentifier &&
uncommitted.EventSourceId == committed.EventSourceId &&
uncommitted.Payload.Equals(committed.Payload) &&
uncommitted.EventSequence == committed.EventSequence);
}
/// <inheritdoc/>
public async Task <CommittedEvent> CommitEvent(
IClientSessionHandle transaction,
EventLogSequenceNumber sequenceNumber,
DateTimeOffset occurred,
Execution.ExecutionContext executionContext,
UncommittedEvent @event,
CancellationToken cancellationToken)
{
var eventSource = EventSourceId.NotSet;
await InsertEvent(
transaction,
sequenceNumber,
occurred,
eventSource,
@event,
new AggregateMetadata(),
executionContext,
cancellationToken).ConfigureAwait(false);
return(new CommittedEvent(
sequenceNumber,
occurred,
eventSource,
executionContext,
@event.Type,
@event.Public,
@event.Content));
}
protected virtual void Emit <TEvent>(TEvent aggregateEvent, IMetadata metadata = null)
where TEvent : IAggregateEvent <TAggregate, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException("aggregateEvent");
}
var now = DateTimeOffset.Now;
var extraMetadata = new Dictionary <string, string>
{
{ MetadataKeys.Timestamp, now.ToString("o") },
{ MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString() },
{ MetadataKeys.AggregateSequenceNumber, (Version + 1).ToString() },
{ MetadataKeys.AggregateName, GetType().Name.Replace("Aggregate", string.Empty) },
};
metadata = metadata == null
? new Metadata(extraMetadata)
: metadata.CloneWith(extraMetadata);
var uncommittedEvent = new UncommittedEvent(aggregateEvent, metadata);
ApplyEvent(aggregateEvent);
_uncommittedEvents.Add(uncommittedEvent);
}
/// <summary>
/// Emits the specified aggregate event.
/// </summary>
/// <typeparam name="TEvent">The type of the event.</typeparam>
/// <param name="aggregateEvent">The aggregate event.</param>
/// <param name="metadata">The metadata.</param>
/// <exception cref="ArgumentNullException">aggregateEvent</exception>
protected override void Emit <TEvent>(TEvent aggregateEvent, IMetadata metadata = null)
{
if (EqualityComparer <TEvent> .Default.Equals(aggregateEvent, default(TEvent)))
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
//Version = (int)sequenceStore.GetNextSequence(EventSequenceTableName);
var aggregateSequenceNumber = Version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.Now;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = (int)aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var uncommittedEvent = new UncommittedEvent(aggregateEvent, eventMetadata);
ApplyEvent(aggregateEvent);
uncommittedEvents.Add(uncommittedEvent);
}
private void SaveEvent(UncommittedEvent evnt, SQLiteTransaction transaction)
{
if (evnt == null || transaction == null)
{
throw new ArgumentNullException();
}
using (var dataStream = new MemoryStream())
{
var bag = _converter.Convert(evnt.Payload);
var formatter = new BinaryFormatter();
formatter.Serialize(dataStream, bag);
var data = dataStream.ToArray();
using (var cmd = new SQLiteCommand(Query.InsertNewEventQuery, transaction.Connection))
{
cmd.SetTransaction(transaction)
.AddParam("SourceId", evnt.EventSourceId)
.AddParam("EventId", evnt.EventIdentifier)
.AddParam("Name", evnt.Payload.GetType().FullName)
.AddParam("Sequence", evnt.EventSequence)
.AddParam("Timestamp", evnt.EventTimeStamp.Ticks)
.AddParam("Data", data);
cmd.ExecuteNonQuery();
}
}
}
protected virtual void Emit <TEvent>(TEvent aggregateEvent, IMetadata metadata = null)
where TEvent : IAggregateEvent <TAggregate, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
var aggregateSequenceNumber = Version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.Now;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var uncommittedEvent = new UncommittedEvent(aggregateEvent, eventMetadata);
ApplyEvent(aggregateEvent);
_uncommittedEvents.Add(uncommittedEvent);
}
protected override void AggregateRootEventAppliedHandler(AggregateRoot aggregateRoot, UncommittedEvent evnt)
{
var message = new EventMessage
{
Body = new StoredEvent
{
Body = evnt.Payload,
CommitId = _commitId,
EventId = evnt.EventIdentifier,
MajorVersion = evnt.EventVersion.Major,
MinorVersion = evnt.EventVersion.Minor,
Sequence = evnt.EventSequence,
TimeStamp = evnt.EventTimeStamp
}
};
IEventStream stream;
var id = aggregateRoot.EventSourceId;
if (!_trackedStreams.TryGetValue(id, out stream))
{
stream = _eventStore.CreateStream(id);
_trackedStreams[id] = stream;
}
stream.Add(message);
_eventStream.Append(evnt);
_dirtyInstances.Add(aggregateRoot);
}
public void Append(UncommittedEvent uncommitted)
{
if (uncommitted == null)
{
throw new ArgumentNullException(nameof(uncommitted));
}
_batch.Add(uncommitted);
}
protected override void OnEventApplied(UncommittedEvent appliedEvent)
{
base.OnEventApplied(appliedEvent);
var callbacks = _eventAppliedCallbacks.Value;
foreach (var callback in callbacks)
{
Log.DebugFormat("Calling event applied callback {0} for event {1} in aggregate root {2}", callback.GetHashCode(), appliedEvent, this);
callback(this, appliedEvent);
}
}
public static void WriteTo(this UncommittedEvent e, Stream outputStream)
{
outputStream.Write(e.StreamId.ToByteArray(), 0, 16);
outputStream.WriteVarInt63(e.SequenceNumber);
outputStream.Write(e.TypeId.ToByteArray(), 0, 16);
outputStream.WriteVarInt63(e.Created.ToUnixTimeMilliseconds());
outputStream.WriteVarInt63(e.Payload.Count);
if (0 < e.Payload.Count)
{
outputStream.Write(e.Payload.Array, e.Payload.Offset, e.Payload.Count);
}
}
public NcqrsEvent(UncommittedEvent @event) :
base(@event.EventSourceId.ToString(), @event.EventIdentifier.ToString())
{
base.Timestamp = @event.EventTimeStamp;
Name = @event.Payload.GetType().AssemblyQualifiedName;
Sequence = @event.EventSequence;
Version = @event.EventVersion.ToString();
if (@event.Payload != null)
{
Data = Utility.Jsonize(@event.Payload, Name);
}
}
public NcqrsEvent(UncommittedEvent @event) :
base(@event.EventSourceId.ToString(), @event.EventIdentifier.ToString())
{
base.Timestamp = @event.EventTimeStamp;
Name = @event.Payload.GetType().AssemblyQualifiedName;
Sequence = @event.EventSequence;
Version = @event.EventVersion.ToString();
if (@event.Payload != null)
{
Data = Utility.Jsonize(@event.Payload, Name);
}
}
private UncommittedEvent GenerateMetadata(UncommittedEvent uncommittedEvent)
{
uncommittedEvent.Metadata = new MetadataCollection(new[]
{
new KeyValuePair <string, object>(MetadataKeys.EventId, Guid.NewGuid()),
new KeyValuePair <string, object>(MetadataKeys.EventVersion, uncommittedEvent.Version),
new KeyValuePair <string, object>(MetadataKeys.Timestamp, DateTime.UtcNow),
new KeyValuePair <string, object>(MetadataKeys.EventClrType, uncommittedEvent.Data.GetType().AssemblyQualifiedName),
new KeyValuePair <string, object>(MetadataKeys.EventName, uncommittedEvent.Data.GetType().Name)
});
return(uncommittedEvent);
}
private static StoredEvent ToStoredEvent(Guid commitId, UncommittedEvent uncommittedEvent)
{
return(new StoredEvent
{
Id = uncommittedEvent.EventSourceId + "/" + uncommittedEvent.EventSequence,
EventIdentifier = uncommittedEvent.EventIdentifier,
EventTimeStamp = uncommittedEvent.EventTimeStamp,
Version = uncommittedEvent.EventVersion,
CommitId = commitId,
Data = uncommittedEvent.Payload,
EventSequence = uncommittedEvent.EventSequence,
EventSourceId = uncommittedEvent.EventSourceId,
});
}
private static StoredEvent ToStoredEvent(Guid commitId, UncommittedEvent uncommittedEvent)
{
return new StoredEvent
{
Id = uncommittedEvent.EventSourceId + "/" + uncommittedEvent.EventSequence,
EventIdentifier = uncommittedEvent.EventIdentifier,
EventTimeStamp = uncommittedEvent.EventTimeStamp,
Version = uncommittedEvent.EventVersion,
CommitId = commitId,
Data = uncommittedEvent.Payload,
EventSequence = uncommittedEvent.EventSequence,
EventSourceId = uncommittedEvent.EventSourceId,
};
}
public IEnumerable <IProcessingElement> Fetch(string pipelineName, int maxCount)
{
lock (this)
{
int count = _random.Next(maxCount);
int available = Count - _fetched;
count = count > available ? available : count;
for (int i = 0; i < count; i++)
{
_fetched++;
var evnt = new UncommittedEvent(Guid.NewGuid(), Guid.NewGuid(), _fetched, _fetched, DateTime.Now, new object(),
new Version(1, 0));
yield return(new SourcedEventProcessingElement(evnt));
}
}
}
private UncommittedEvent GenerateMetadata(UncommittedEvent uncommittedEvent)
{
var metadatas = _metadataProviders.SelectMany(md => md.Provide(uncommittedEvent.Aggregate,
uncommittedEvent.Data,
MetadataCollection.Empty)).Concat(new[]
{
new KeyValuePair <string, object>(MetadataKeys.EventId, Guid.NewGuid()),
new KeyValuePair <string, object>(MetadataKeys.EventVersion, uncommittedEvent.Version),
new KeyValuePair <string, object>(MetadataKeys.Timestamp, DateTime.UtcNow),
});
var metadata = new MetadataCollection(metadatas);
uncommittedEvent.Metadata = uncommittedEvent.Metadata.Merge(metadata);
return(uncommittedEvent);
}
public UncommittedEventStream ForSourceUncomitted(Guid id, Guid commitId, int sequenceOffset = 0)
{
int sequence = sequenceOffset + 1;
int initialVersion = sequenceOffset == 0 ? 1 : sequenceOffset;
var comittedEvents = new List <CommittedEvent>();
var result = new UncommittedEventStream(commitId);
foreach (var evnt in _events)
{
var uncommittedEvent = new UncommittedEvent(Guid.NewGuid(), id, sequence, initialVersion, DateTime.UtcNow,
evnt, new Version(1, 0));
result.Append(uncommittedEvent);
sequence++;
}
return(result);
}
public byte[] GetBytes(UncommittedEvent evnt)
{
string eventName;
JObject serializedPayload = _formatter.Serialize(evnt.Payload, out eventName);
var output = new MemoryStream();
var writer = new BinaryWriter(output);
writer.Write(evnt.CommitId.ToByteArray());
writer.Write(evnt.EventIdentifier.ToByteArray());
writer.Write(evnt.EventSequence);
writer.Write(evnt.EventTimeStamp.Ticks);
writer.Write(eventName);
writer.Write(evnt.EventVersion.ToString());
var bsonWriter = new BsonWriter(output);
serializedPayload.WriteTo(bsonWriter);
bsonWriter.Flush();
output.Flush();
return output.ToArray();
}
public void SetUp()
{
_testEvent = new UncommittedEvent(Guid.NewGuid(), Guid.NewGuid(), 1, 1, DateTime.UtcNow, new FakeEvent(),
new Version(1, 0));
_handler1 = MockRepository.GenerateMock <IEventHandler <FakeEvent> >();
_handler2 = MockRepository.GenerateMock <IEventHandler <FakeEventBase> >();
_handler3 = MockRepository.GenerateMock <IEventHandler <IFakeEventInterface> >();
_container = new WindsorContainer();
_container.Register(
Component.For <IWindsorContainer>().Instance(_container),
Component.For <IEventHandler <FakeEvent> >().Instance(_handler1),
Component.For <IEventHandler <FakeEventBase> >().Instance(_handler2),
Component.For <IEventHandler <IFakeEventInterface> >().Instance(_handler3),
Component.For <IEventBus>().ImplementedBy <WindsorInProcessEventBus>());
var svc = _container.Resolve <IEventBus>();
svc.Publish(_testEvent);
}
internal protected void ApplyEvent(object evnt)
{
Log.DebugFormat("Applying an event to event source {0}", evnt);
var eventVersion = evnt.GetType().Assembly.GetName().Version;
var eventSequence = GetNextSequence();
var wrappedEvent = new UncommittedEvent(_idGenerator.GenerateNewId(), EventSourceId, eventSequence, _initialVersion, DateTime.UtcNow, evnt, eventVersion);
//Legacy stuff...
var sourcedEvent = evnt as ISourcedEvent;
if (sourcedEvent != null)
{
sourcedEvent.ClaimEvent(EventSourceId, eventSequence);
}
Log.DebugFormat("Handling event {0} in event source {1}", wrappedEvent, this);
HandleEvent(wrappedEvent.Payload);
Log.DebugFormat("Notifying about application of an event {0} to event source {1}", wrappedEvent, this);
OnEventApplied(wrappedEvent);
}
public byte[] GetBytes(UncommittedEvent evnt)
{
string eventName;
JObject serializedPayload = _formatter.Serialize(evnt.Payload, out eventName);
var output = new MemoryStream();
var writer = new BinaryWriter(output);
writer.Write(evnt.CommitId.ToByteArray());
writer.Write(evnt.EventIdentifier.ToByteArray());
writer.Write(evnt.EventSequence);
writer.Write(evnt.EventTimeStamp.Ticks);
writer.Write(eventName);
writer.Write(evnt.EventVersion.ToString());
var bsonWriter = new BsonWriter(output);
serializedPayload.WriteTo(bsonWriter);
bsonWriter.Flush();
output.Flush();
return(output.ToArray());
}
/// <summary>Saves the event to the data store.</summary>
/// <param name="evnt">The event to save.</param>
/// <param name="transaction">The transaction.</param>
private void SaveEvent(UncommittedEvent evnt, NpgsqlTransaction transaction)
{
string eventName;
var document = _formatter.Serialize(evnt.Payload, out eventName);
var storedEvent = new StoredEvent <JObject>(evnt.EventIdentifier, evnt.EventTimeStamp, eventName, evnt.EventVersion, evnt.EventSourceId, evnt.EventSequence, document);
var raw = _translator.TranslateToRaw(storedEvent);
using (var command = new NpgsqlCommand(Queries.InsertNewEventQuery, transaction.Connection))
{
command.Transaction = transaction;
command.Parameters.AddWithValue("EventId", raw.EventIdentifier);
command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp);
command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId);
command.Parameters.AddWithValue("Name", raw.EventName);
command.Parameters.AddWithValue("Version", raw.EventVersion.ToString());
command.Parameters.AddWithValue("Sequence", raw.EventSequence);
command.Parameters.AddWithValue("Data", raw.Data);
command.ExecuteNonQuery();
}
}
public void SetUp()
{
_testEvent = new UncommittedEvent(Guid.NewGuid(), Guid.NewGuid(), 1, 1, DateTime.UtcNow, new FakeEvent(),
new Version(1, 0));
_handler1 = new Mock <IEventHandler <FakeEvent> >(MockBehavior.Strict);
_handler1.Setup(x => x.Handle(It.IsAny <IPublishedEvent <FakeEvent> >())).Verifiable();
_handler2 = new Mock <IEventHandler <FakeEventBase> >(MockBehavior.Strict);
_handler2.Setup(x => x.Handle(It.IsAny <IPublishedEvent <FakeEventBase> >())).Verifiable();
_handler3 = new Mock <IEventHandler <IFakeEventInterface> >(MockBehavior.Strict);
_handler3.Setup(x => x.Handle(It.IsAny <IPublishedEvent <IFakeEventInterface> >())).Verifiable();
_container = new WindsorContainer();
_container.Register(
Component.For <IWindsorContainer>().Instance(_container),
Component.For <IEventHandler <FakeEvent> >().Instance(_handler1.Object),
Component.For <IEventHandler <FakeEvent> >().Instance(_handler2.Object),
Component.For <IEventHandler <FakeEvent> >().Instance(_handler3.Object),
Component.For <IEventBus>().ImplementedBy <WindsorInProcessEventBus>());
var svc = _container.Resolve <IEventBus>();
svc.Publish(_testEvent);
}
/// <inheritdoc/>
public async Task <CommittedAggregateEvent> CommitAggregateEvent(
IClientSessionHandle transaction,
Artifact aggregateRoot,
AggregateRootVersion aggregateRootVersion,
EventLogSequenceNumber version,
DateTimeOffset occurred,
EventSourceId eventSource,
Execution.ExecutionContext executionContext,
UncommittedEvent @event,
CancellationToken cancellationToken)
{
await InsertEvent(
transaction,
version,
occurred,
eventSource,
@event,
new AggregateMetadata
{
WasAppliedByAggregate = true,
TypeId = aggregateRoot.Id,
TypeGeneration = aggregateRoot.Generation,
Version = aggregateRootVersion
},
executionContext,
cancellationToken).ConfigureAwait(false);
return(new CommittedAggregateEvent(
aggregateRoot,
aggregateRootVersion,
version,
occurred,
eventSource,
executionContext,
@event.Type,
@event.Public,
@event.Content));
}
protected void Emit <TEvent>(TEvent aggregateEvent, IMetadata metadata = null)
where TEvent : AggregateEvent <TAggregate>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException("aggregateEvent");
}
var extraMetadata = new Dictionary <string, string>
{
{ MetadataKeys.Timestamp, DateTimeOffset.Now.ToString("o") },
{ MetadataKeys.AggregateSequenceNumber, (Version + 1).ToString() }
};
metadata = metadata == null
? new Metadata(extraMetadata)
: metadata.CloneWith(extraMetadata);
var uncommittedEvent = new UncommittedEvent(aggregateEvent, metadata);
ApplyEvent(aggregateEvent);
_uncommittedEvents.Add(uncommittedEvent);
}
protected override void AggregateRootEventAppliedHandler(AggregateRoot aggregateRoot, UncommittedEvent evnt)
{
RegisterDirtyInstance(aggregateRoot);
_eventStream.Append(evnt);
}
protected override void AggregateRootEventAppliedHandler(AggregateRoot aggregateRoot, UncommittedEvent evnt)
{
var message = new EventMessage
{
Body = new StoredEvent
{
Body = evnt.Payload,
CommitId = _commitId,
EventId = evnt.EventIdentifier,
MajorVersion = evnt.EventVersion.Major,
MinorVersion = evnt.EventVersion.Minor,
Sequence = evnt.EventSequence,
TimeStamp = evnt.EventTimeStamp
}
};
IEventStream stream;
var id = aggregateRoot.EventSourceId;
if (!_trackedStreams.TryGetValue(id, out stream))
{
stream = _eventStore.CreateStream(id);
_trackedStreams[id] = stream;
}
stream.Add(message);
_eventStream.Append(evnt);
_dirtyInstances.Add(aggregateRoot);
}
/// <summary>
/// Saves the event to the data store.
/// </summary>
/// <param name="evnt">The event to save.</param>
/// <param name="transaction">The transaction.</param>
private void SaveEvent(UncommittedEvent evnt, NpgsqlTransaction transaction)
{
string eventName;
var document = _formatter.Serialize(evnt.Payload, out eventName);
var storedEvent = new StoredEvent<JObject>(evnt.EventIdentifier, evnt.EventTimeStamp,
eventName, evnt.EventVersion, evnt.EventSourceId,
evnt.EventSequence, document);
var raw = _translator.TranslateToRaw(storedEvent);
using (var command = new NpgsqlCommand(Queries.InsertNewEventQuery, transaction.Connection))
{
command.Transaction = transaction;
command.Parameters.AddWithValue("EventId", raw.EventIdentifier);
command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp);
command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId);
command.Parameters.AddWithValue("Name", raw.EventName);
command.Parameters.AddWithValue("Version", raw.EventVersion.ToString());
command.Parameters.AddWithValue("Sequence", raw.EventSequence);
command.Parameters.AddWithValue("Data", raw.Data);
command.ExecuteNonQuery();
}
}
protected internal void ApplyEvent(object evnt)
{
Log.DebugFormat("Applying an event to event source {0}", evnt);
var eventVersion = evnt.GetType().Assembly.GetName().Version;
var eventSequence = GetNextSequence();
//Legacy stuff...
var sourcedEvent = evnt as ISourcedEvent;
if (sourcedEvent != null)
{
sourcedEvent.ClaimEvent(EventSourceId, eventSequence);
}
var wrappedEvent = new UncommittedEvent(_idGenerator.GenerateNewId(), EventSourceId, eventSequence, _initialVersion, DateTime.UtcNow, evnt, eventVersion);
Log.DebugFormat("Handling event {0} in event source {1}", wrappedEvent, this);
HandleEvent(wrappedEvent.Payload);
Log.DebugFormat("Notifying about application of an event {0} to event source {1}", wrappedEvent, this);
OnEventApplied(wrappedEvent);
}
protected virtual void OnEventApplied(UncommittedEvent evnt)
{
if (EventApplied != null)
{
EventApplied(this, new EventAppliedEventArgs(evnt));
}
}
public EventAppliedEventArgs(UncommittedEvent evnt)
{
_event = evnt;
}
protected override void Given()
{
SetupDependencies();
PublishedEvents = new UncommittedEvent[0];
ExecutedCommand = WhenExecuting();
}
/// <summary>Saves the event to the data store.</summary>
/// <param name="uncommittedEvent">The event to save.</param>
/// <param name="transaction">The transaction.</param>
private void SaveEvent(UncommittedEvent uncommittedEvent, SqlTransaction transaction)
{
Contract.Requires<ArgumentNullException>(uncommittedEvent != null, "The argument uncommittedEvent could not be null.");
Contract.Requires<ArgumentNullException>(transaction != null, "The argument transaction could not be null.");
string eventName;
var document = _formatter.Serialize(uncommittedEvent.Payload, out eventName);
var storedEvent = new StoredEvent<JObject>(uncommittedEvent.EventIdentifier, uncommittedEvent.EventTimeStamp,
eventName, uncommittedEvent.EventVersion, uncommittedEvent.EventSourceId,
uncommittedEvent.EventSequence, document);
var raw = _translator.TranslateToRaw(storedEvent);
using (var command = new SqlCommand(Queries.InsertNewEventQuery, transaction.Connection))
{
command.Transaction = transaction;
command.Parameters.AddWithValue("EventId", raw.EventIdentifier);
command.Parameters.AddWithValue("TimeStamp", raw.EventTimeStamp);
command.Parameters.AddWithValue("EventSourceId", raw.EventSourceId);
command.Parameters.AddWithValue("Name", raw.EventName);
command.Parameters.AddWithValue("Version", raw.EventVersion.ToString());
command.Parameters.AddWithValue("Sequence", raw.EventSequence);
command.Parameters.AddWithValue("Data", raw.Data);
command.ExecuteNonQuery();
}
}
private void SaveEvent(UncommittedEvent evnt, SQLiteTransaction transaction)
{
if (evnt == null || transaction == null) throw new ArgumentNullException();
using (var dataStream = new MemoryStream())
{
var bag = _converter.Convert(evnt.Payload);
var formatter = new BinaryFormatter();
formatter.Serialize(dataStream, bag);
var data = dataStream.ToArray();
using (var cmd = new SQLiteCommand(Query.InsertNewEventQuery, transaction.Connection))
{
cmd.SetTransaction(transaction)
.AddParam("SourceId", evnt.EventSourceId)
.AddParam("EventId", evnt.EventIdentifier)
.AddParam("Name", evnt.Payload.GetType().FullName)
.AddParam("Sequence", evnt.EventSequence)
.AddParam("Timestamp", evnt.EventTimeStamp.Ticks)
.AddParam("Data", data);
cmd.ExecuteNonQuery();
}
}
}
private static bool AreEqual(UncommittedEvent uncommitted, CommittedEvent committed)
{
return uncommitted.EventIdentifier == committed.EventIdentifier
&& uncommitted.EventSourceId == committed.EventSourceId
&& uncommitted.Payload.Equals(committed.Payload)
&& uncommitted.EventTimeStamp == committed.EventTimeStamp
&& uncommitted.EventSequence == committed.EventSequence;
}