/// <inheritdoc/>
public ICommand Convert(CommandRequest request)
{
// todo: Cache it per transaction / command context
var type = _applicationResourceResolver.Resolve(request.Type);
// todo: Verify that it is a an ICommand
var instance = Activator.CreateInstance(type) as ICommand;
var properties = type.GetTypeInfo().DeclaredProperties.ToDictionary(p => p.Name, p => p);
// todo: Verify that the command shape matches 100% - do not allow anything else
// todo: Convert to target type if mismatch
request.Content.Keys.ForEach(propertyName =>
{
if (properties.ContainsKey(propertyName))
{
var property = properties[propertyName];
object value = request.Content[propertyName];
if (property.PropertyType.IsConcept())
{
value = ConceptFactory.CreateConceptInstance(property.PropertyType, value);
}
else if (property.PropertyType == typeof(DateTimeOffset) && value.GetType() == typeof(DateTime))
{
value = new DateTimeOffset((DateTime)value);
}
property.SetValue(instance, value);
}
});
return(instance);
}
/// <inheritdoc/>
public IEnumerable <EventAndEnvelope> GetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var eventSourceIdentifier = _applicationResourceIdentifierConverter.AsString(eventSource);
var eventPath = GetPathFor(eventSourceIdentifier, eventSourceId);
var files = _files.GetFilesIn(eventPath).OrderBy(f => f);
var eventFiles = files.Where(f => f.EndsWith(".event")).ToArray();
var envelopeFiles = files.Where(f => f.EndsWith(".envelope")).ToArray();
if (eventFiles.Length != envelopeFiles.Length)
{
throw new Exception($"There is a problem with event files for {eventSourceIdentifier} with Id {eventSourceId}");
}
var events = new List <EventAndEnvelope>();
for (var eventIndex = 0; eventIndex < eventFiles.Length; eventIndex++)
{
var envelopeFile = envelopeFiles[eventIndex];
var eventFile = eventFiles[eventIndex];
var envelopeAsJson = _files.ReadString(Path.GetDirectoryName(envelopeFile), Path.GetFileName(envelopeFile));
var eventAsJson = _files.ReadString(Path.GetDirectoryName(eventFile), Path.GetFileName(eventFile));
var envelopeValues = _serializer.GetKeyValuesFromJson(envelopeAsJson);
var _correllationId = Guid.Parse((string)envelopeValues["CorrelationId"]);
var _eventId = Guid.Parse((string)envelopeValues["EventId"]);
var _sequenceNumber = (long)envelopeValues["SequenceNumber"];
var _sequenceNumberForEventType = (long)envelopeValues["SequenceNumberForEventType"];
var _generation = (long)envelopeValues["Generation"];
var _event = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["Event"]);
var _eventSourceId = Guid.Parse((string)envelopeValues["EventSourceId"]);
var _eventSource = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["EventSource"]);
var _eventSourceVersion = EventSourceVersion.FromCombined(double.Parse(envelopeValues["Version"].ToString()));
var _causedBy = (string)envelopeValues["CausedBy"];
var _occurred = (DateTime)envelopeValues["Occurred"];
var envelope = new EventEnvelope(
_correllationId,
_eventId,
_sequenceNumber,
_sequenceNumberForEventType,
(int)_generation,
_event,
_eventSourceId,
_eventSource,
_eventSourceVersion,
_causedBy,
_occurred
);
var eventType = _applicationResourceResolver.Resolve(envelope.Event);
var @event = Activator.CreateInstance(eventType, eventSourceId) as IEvent;
_serializer.FromJson(@event, eventAsJson);
events.Add(new EventAndEnvelope(envelope, @event));
}
return(events);
}
Task Receive(Message message, CancellationToken token)
{
var dynamicEventsAndEnvelopes = new List <dynamic>();
var json = System.Text.Encoding.UTF8.GetString(message.Body);
_serializer.FromJson(dynamicEventsAndEnvelopes, json);
var eventsAndEnvelopes = new List <EventAndEnvelope>();
foreach (var dynamicEventAndEnvelope in dynamicEventsAndEnvelopes)
{
var env = dynamicEventAndEnvelope.Envelope;
var correlationId = (TransactionCorrelationId)Guid.Parse(env.CorrelationId.ToString());
var eventId = (EventId)Guid.Parse(env.EventId.ToString());
var sequenceNumber = (EventSequenceNumber)long.Parse(env.SequenceNumber.ToString());
var sequenceNumberForEventType = (EventSequenceNumber)long.Parse(env.SequenceNumberForEventType.ToString());
var generation = (EventGeneration)long.Parse(env.Generation.ToString());
var @event = _applicationResourceIdentifierConverter.FromString(env.Event.ToString());
var eventSourceId = (EventSourceId)Guid.Parse(env.EventSourceId.ToString());
var eventSource = _applicationResourceIdentifierConverter.FromString(env.EventSource.ToString());
var version = (EventSourceVersion)EventSourceVersion.FromCombined(double.Parse(env.Version.ToString()));
var causedBy = (CausedBy)env.CausedBy.ToString();
var occurred = DateTimeOffset.Parse(env.Occurred.ToString());
var envelope = new EventEnvelope(
correlationId,
eventId,
sequenceNumber,
sequenceNumberForEventType,
generation,
@event,
eventSourceId,
eventSource,
version,
causedBy,
occurred
);
var eventType = _applicationResourceResolver.Resolve(@event);
var eventInstance = Activator.CreateInstance(eventType, new object[] { eventSourceId }) as IEvent;
var e = dynamicEventAndEnvelope.Event.ToString();
_serializer.FromJson(eventInstance, e);
eventsAndEnvelopes.Add(new EventAndEnvelope(envelope, eventInstance));
}
var stream = new CommittedEventStream(eventsAndEnvelopes.First().Envelope.EventSourceId, eventsAndEnvelopes);
Received(stream);
_queueClient.CompleteAsync(message.SystemProperties.LockToken);
return(Task.CompletedTask);
}
/// <inheritdoc/>
public IEnumerable <EventAndEnvelope> GetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var partitionKeyFilter = GetPartitionKeyFilterFor(eventSource, eventSourceId);
var query = new TableQuery <DynamicTableEntity>().Where(partitionKeyFilter);
var events = new List <DynamicTableEntity>();
TableContinuationToken continuationToken = null;
do
{
_table.ExecuteQuerySegmentedAsync(query, continuationToken).ContinueWith(e =>
{
events.AddRange(e.Result.Results);
continuationToken = e.Result.ContinuationToken;
}).Wait();
} while (continuationToken != null);
var eventsAndEnvelopes = events.OrderBy(e => long.Parse(e.RowKey)).Select(entity => {
var eventResource = GetApplicationResourceIdentifierFromSanitizedString(entity.Properties[PropertiesFor <EventEnvelope> .GetPropertyName(e => e.Event)].StringValue);
var eventSourceResource = GetApplicationResourceIdentifierFromSanitizedString(entity.Properties[PropertiesFor <EventEnvelope> .GetPropertyName(e => e.EventSource)].StringValue);
var envelope = new EventEnvelope(
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.CorrelationId),
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.EventId),
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.SequenceNumber),
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.SequenceNumberForEventType),
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.Generation),
eventResource,
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.EventSourceId),
eventSourceResource,
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.Version),
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.CausedBy),
PropertiesFor <EventEnvelope> .GetValue(entity, e => e.Occurred)
);
var eventType = _applicationResourceResolver.Resolve(envelope.Event);
var @event = Activator.CreateInstance(eventType, envelope.EventSourceId) as IEvent;
eventType.GetProperties().Where(p => p.CanWrite).ForEach(p => p.SetValue(@event, PropertyHelper.GetValue(entity, p)));
return(new EventAndEnvelope(envelope, @event));
});
return(eventsAndEnvelopes);
}
/// <summary>
/// Initializes a new instance of <see cref="CommittedEventStreamCoordinator"/>
/// </summary>
/// <param name="serializer"><see cref="ISerializer"/> to use for deserializing <see cref="IEvent">events</see></param>
/// <param name="applicationResourceIdentifierConverter"><see cref="IApplicationResourceIdentifierConverter"/> used for converting resource identifiers</param>
/// <param name="applicationResourceResolver"><see cref="IApplicationResourceResolver"/> used for resolving types from <see cref="IApplicationResourceIdentifier"/></param>
/// <param name="connectionStringProvider"><see cref="ICanProvideConnectionStringToReceiver">Provider</see> of connection string</param>
public CommittedEventStreamReceiver(
ISerializer serializer,
IApplicationResourceIdentifierConverter applicationResourceIdentifierConverter,
IApplicationResourceResolver applicationResourceResolver,
ICanProvideConnectionStringToReceiver connectionStringProvider)
{
_serializer = serializer;
var factory = new ConnectionFactory();
factory.Uri = connectionStringProvider();
var connection = factory.CreateConnection();
var exchangeName = "Events";
var routingKey = "RoutingKey";
var queueName = "Events";
var model = connection.CreateModel();
model.ExchangeDeclare(exchangeName, ExchangeType.Direct);
model.QueueDeclare(queueName, false, false, false, null);
model.QueueBind(queueName, exchangeName, routingKey, null);
var consumer = new EventingBasicConsumer(model);
consumer.Received += (ch, ea) =>
{
try
{
var dynamicEventsAndEnvelopes = new List <dynamic>();
var json = System.Text.Encoding.UTF8.GetString(ea.Body);
_serializer.FromJson(dynamicEventsAndEnvelopes, json);
var eventsAndEnvelopes = new List <EventAndEnvelope>();
foreach (var dynamicEventAndEnvelope in dynamicEventsAndEnvelopes)
{
var env = dynamicEventAndEnvelope.Envelope;
var correlationId = (TransactionCorrelationId)Guid.Parse(env.CorrelationId.ToString());
var eventId = (EventId)Guid.Parse(env.EventId.ToString());
var sequenceNumber = (EventSequenceNumber)long.Parse(env.SequenceNumber.ToString());
var sequenceNumberForEventType = (EventSequenceNumber)long.Parse(env.SequenceNumberForEventType.ToString());
var generation = (EventGeneration)long.Parse(env.Generation.ToString());
var @event = applicationResourceIdentifierConverter.FromString(env.Event.ToString());
var eventSourceId = (EventSourceId)Guid.Parse(env.EventSourceId.ToString());
var eventSource = applicationResourceIdentifierConverter.FromString(env.EventSource.ToString());
var version = (EventSourceVersion)EventSourceVersion.FromCombined(double.Parse(env.Version.ToString()));
var causedBy = (CausedBy)env.CausedBy.ToString();
var occurred = DateTimeOffset.Parse(env.Occurred.ToString());
var envelope = new EventEnvelope(
correlationId,
eventId,
sequenceNumber,
sequenceNumberForEventType,
generation,
@event,
eventSourceId,
eventSource,
version,
causedBy,
occurred
);
var eventType = applicationResourceResolver.Resolve(@event);
var eventInstance = Activator.CreateInstance(eventType, new object[] { eventSourceId }) as IEvent;
var e = dynamicEventAndEnvelope.Event.ToString();
_serializer.FromJson(eventInstance, e);
eventsAndEnvelopes.Add(new EventAndEnvelope(envelope, eventInstance));
}
var stream = new CommittedEventStream(eventsAndEnvelopes.First().Envelope.EventSourceId, eventsAndEnvelopes);
Received(stream);
model.BasicAck(ea.DeliveryTag, false);
}
catch
{
}
finally
{
}
};
Task.Run(() => model.BasicConsume(queueName, false, consumer));
}