private CommittedEvent ReadEventFromDbReader(NpgsqlDataReader reader)
{
StoredEvent<string> rawEvent = ReadEvent(reader);
var document = _translator.TranslateToCommon(rawEvent);
_converter.Upgrade(document);
var payload = _formatter.Deserialize(document.Data, document.EventName);
// TODO: Legacy stuff... we do not have a dummy id with the current schema.
var dummyCommitId = Guid.Empty;
var evnt = new CommittedEvent(dummyCommitId, document.EventIdentifier, document.EventSourceId, document.EventSequence, document.EventTimeStamp, payload, document.EventVersion);
// TODO: Legacy stuff... should move.
if (evnt is ISourcedEvent) { ((ISourcedEvent)evnt).InitializeFrom(rawEvent); }
return evnt;
}
public virtual CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent> From <TAggregateEvent>(TAggregateEvent aggregateEvent,
long version, IMetadata metadata = null)
where TAggregateEvent : IAggregateEvent <TAggregateSaga, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
_eventDefinitionService.Load(aggregateEvent.GetType());
var eventDefinition = _eventDefinitionService.GetDefinition(aggregateEvent.GetType());
var aggregateSequenceNumber = version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var committedEvent = new CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, aggregateSequenceNumber);
return(committedEvent);
}
public void CommittedEvent_WhenTagged_ContainsAggregateEventAsTaggedElement()
{
var aggregateEventTagger = new AggregateEventTagger(new EventDefinitions());
var aggregateSequenceNumber = 3;
var aggregateId = TestAggregateId.New;
var entityId = TestId.New;
var entity = new Test(entityId);
var aggregateEvent = new TestAddedEvent(entity);
var now = DateTimeOffset.UtcNow;
var eventId = EventId.NewDeterministic(GuidFactories.Deterministic.Namespaces.Events, $"{aggregateId.Value}-v{3}");
var eventMetadata = new EventMetadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = typeof(TestAggregate).GetAggregateName().Value,
AggregateId = aggregateId.Value,
EventId = eventId
};
var committedEvent = new CommittedEvent <TestAggregateId, TestAddedEvent>(
aggregateId,
aggregateEvent,
eventMetadata,
now,
aggregateSequenceNumber);
var taggedEvent = aggregateEventTagger.ToJournal(committedEvent);
if (taggedEvent is Tagged a)
{
a.Tags.Should().Contain("TestAdded");
}
else
{
false.Should().BeTrue();
}
}
private void ValidateHistoricalEvent(CommittedEvent evnt)
{
if (evnt.EventSourceId != EventSourceId)
{
var message = String.Format("Cannot apply historical event from other event source.");
throw new InvalidOperationException(message);
}
// TODO: Do we really really need this check? Why don't we trust IEventStore?
if (evnt.EventSequence != Version + 1)
{
var message = String.Format("Cannot apply event with sequence {0}. Since the initial version of the " +
"aggregate root is {1}. Only an event with sequence number {2} can be applied.",
evnt.EventSequence, Version, Version + 1);
throw new InvalidOperationException(message);
}
}
/// <inheritdoc/>
public Task <IProcessingResult> Process(CommittedEvent @event, PartitionId partitionId, string failureReason, uint retryCount, CancellationToken cancellationToken)
{
_logger.Trace("Retrying processing of Event from Event Horizon");
return(Process(@event, cancellationToken));
}
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, CancellationToken cancellationToken);
/// <summary> /// Gets the <see cref="AggregateMetadata" /> from a <see cref="CommittedEvent" />. /// </summary> /// <param name="committedEvent">The <see cref="CommittedEvent" />.</param> /// <returns>The <see cref="AggregateMetadata"/>.</returns> public static AggregateMetadata GetAggregateMetadata(this CommittedEvent committedEvent) => committedEvent is CommittedAggregateEvent aggregateEvent ?
/// <summary> /// Gets the <see cref="EventMetadata"/> from the <see cref="CommittedEvent"/>. /// </summary> /// <param name="committedEvent">The <see cref="CommittedEvent"/>.</param> /// <returns>The converted <see cref="EventMetadata" />.</returns> public static EventMetadata GetEventMetadata(this CommittedEvent committedEvent) =>
/// <inheritdoc/> public override Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken) => Filter(@event, partitionId, eventProcessorId, executionContext, cancellationToken);
/// <inheritdoc/> public Task Write(CommittedEvent @event, ScopeId scope, StreamId streamId, PartitionId partitionId, CancellationToken cancellationToken) => Write(@event, streamId, partitionId, cancellationToken);
/// <summary> /// Convert to a protobuf message representation of <see cref="CommittedEvent"/>. /// </summary> /// <param name="event"><see cref="CommittedEvent"/> to convert from.</param> /// <returns>Converted <see cref="Contracts.CommittedEvent"/>.</returns> public static Contracts.CommittedEvent ToProtobuf(this CommittedEvent @event) => @event is CommittedExternalEvent externalEvent?
/// <summary> /// Gets the <see cref="EventHorizonMetadata"/> from the <see cref="CommittedEvent"/>. /// </summary> /// <param name="committedEvent">The <see cref="CommittedEvent"/>.</param> /// <returns>The converted <see cref="EventHorizonMetadata" />.</returns> public static EventHorizonMetadata GetEventHorizonMetadata(this CommittedEvent committedEvent) => committedEvent is CommittedExternalEvent externalEvent?
/// <inheritdoc/>
public Task <IProcessingResult> Process(CommittedEvent @event, PartitionId partitionId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken)
{
Log.RetryProcessEvent(_logger, _subscriptionId);
return(Process(@event, cancellationToken));
}
/// <inheritdoc/> public Task <IProcessingResult> Process(CommittedEvent @event, PartitionId partitionId, ExecutionContext executionContext, CancellationToken cancellationToken) => Process(@event, cancellationToken);
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;
}
private void CommittedEvent_Trans(CommittedEvent evt, EventEnvelope envelope)
{
// Put your code here
throw new NotImplementedException();
}
/// <inheritdoc/> public Task <IProjectionResult> Project(ProjectionCurrentState state, CommittedEvent @event, PartitionId partitionId, ExecutionContext executionContext, CancellationToken cancellationToken) => Process(state, @event, partitionId, new ProjectionRequest(), executionContext, cancellationToken);
bool ShouldProcessEvent(CommittedEvent @event) => _projectionDefinition.Events.Select(_ => _.EventType).Contains(@event.Type.Id);
bool TryGetKey(ProjectionEventSelector eventSelector, CommittedEvent @event, PartitionId partition, out ProjectionKey key) => PartitionIsKey(eventSelector.KeySelectorType, partition, out key) || EventSourceIsKey(eventSelector.KeySelectorType, @event.EventSource, out key) || PropertyIsKey(eventSelector.KeySelectorType, @event.Content, eventSelector.KeySelectorExpression, out key) || StaticIsKey(eventSelector.KeySelectorType, eventSelector.StaticKey, out key) || OccurredIsKey(eventSelector.KeySelectorType, eventSelector.OccurredFormat, @event.Occurred, out key);
public CouldNotGetProjectionKey(CommittedEvent @event)
: base($"Could not get projection key from event on sequence number {@event.EventLogSequenceNumber} with content '{@event.Content}'")
{
}
/// <summary>
///
/// </summary>
/// <param name="issuccess"></param>
protected virtual void OnCommittedEvent(bool issuccess)
{
CommittedEvent?.Invoke(issuccess);
}
public void On(CommittedEvent evnt)
{
CommittedEventProcessed = true;
}
public Task <FilterResult> Filter(CommittedEvent @event)
{
_logger.Warning("Filtering public event '{Event}'", @event);
return(Task.FromResult(new FilterResult(true)));
}
private void ApplyEventFromHistory(CommittedEvent evnt)
{
ValidateHistoricalEvent(evnt);
Log.DebugFormat("Handling historical event {0} in event source {1}", evnt, this);
HandleEvent(evnt.Payload);
_currentVersion++;
}
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, CancellationToken cancellationToken);
protected virtual void Emit <TAggregateEvent>(TAggregateEvent aggregateEvent, IMetadata metadata = null)
where TAggregateEvent : IAggregateEvent <TAggregateSaga, TIdentity>
{
if (aggregateEvent == null)
{
throw new ArgumentNullException(nameof(aggregateEvent));
}
_eventDefinitionService.Load(typeof(TAggregateEvent));
var eventDefinition = _eventDefinitionService.GetDefinition(typeof(TAggregateEvent));
var aggregateSequenceNumber = Version + 1;
var eventId = EventId.NewDeterministic(
GuidFactories.Deterministic.Namespaces.Events,
$"{Id.Value}-v{aggregateSequenceNumber}");
var now = DateTimeOffset.UtcNow;
var eventMetadata = new Metadata
{
Timestamp = now,
AggregateSequenceNumber = aggregateSequenceNumber,
AggregateName = Name.Value,
AggregateId = Id.Value,
EventId = eventId,
EventName = eventDefinition.Name,
EventVersion = eventDefinition.Version,
};
eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString());
if (metadata != null)
{
eventMetadata.AddRange(metadata);
}
var committedEvent = new CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version);
Persist(committedEvent, ApplyCommittedEvents);
Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]");
Version++;
var aggregateApplyMethod = GetEventApplyMethods(aggregateEvent);
Persist(aggregateEvent, aggregateApplyMethod);
Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]");
Version++;
var domainEvent = new DomainEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version);
Publish(domainEvent);
if (SnapshotStrategy.ShouldCreateSnapshot(this))
{
var aggregateSnapshot = CreateSnapshot();
if (aggregateSnapshot != null)
{
var t = aggregateSnapshot.GetType();
_snapshotDefinitionService.Load(aggregateSnapshot.GetType());
var snapshotDefinition = _snapshotDefinitionService.GetDefinition(aggregateSnapshot.GetType());
var snapshotMetadata = new Aggregates.Snapshot.SnapshotMetadata
{
AggregateId = Id.Value,
AggregateName = Name.Value,
AggregateSequenceNumber = Version,
SnapshotName = snapshotDefinition.Name,
SnapshotVersion = snapshotDefinition.Version
};
var commitedSnapshot =
new ComittedSnapshot <TAggregateSaga, TIdentity, IAggregateSnapshot <TAggregateSaga, TIdentity> >(
Id,
aggregateSnapshot,
snapshotMetadata,
now, Version);
SaveSnapshot(commitedSnapshot);
}
}
}
