private static Func <StoredEvent, IEvent> DeserializeAsDynamicEvent(
DeserializeEvent deserialize)
{
return(e =>
{
dynamic deserializeObject = deserialize(e.Body);
var dynamicEvent = new DynamicEvent(deserializeObject)
{
EventStreamName = e.StreamName,
EventTypeName = e.EventTypeName,
AggregateId = e.AggregateId,
SequenceNumber = e.SequenceNumber,
Timestamp = e.Timestamp,
ETag = e.ETag
};
return dynamicEvent;
});
}
private static Func <StoredEvent, IEvent> DeserializeAsDynamicEvent(
JsonSerializerSettings serializerSettings)
{
return(e =>
{
dynamic deserializeObject = JsonConvert.DeserializeObject(e.Body, serializerSettings);
var dynamicEvent = new DynamicEvent(deserializeObject)
{
EventStreamName = e.StreamName,
EventTypeName = e.EventTypeName,
AggregateId = e.AggregateId,
SequenceNumber = e.SequenceNumber,
Timestamp = e.Timestamp,
ETag = e.ETag
};
return dynamicEvent;
});
}
/// <summary>
/// Deserializes a domain event.
/// </summary>
/// <param name="aggregateName">Name of the aggregate.</param>
/// <param name="eventName">Name of the event type.</param>
/// <param name="aggregateId">The aggregate identifier.</param>
/// <param name="sequenceNumber">The sequence number of the event.</param>
/// <param name="timestamp">The timestamp of the event.</param>
/// <param name="body">The body of the event.</param>
/// <param name="uniqueEventId">The unique event identifier.</param>
/// <param name="serializerSettings">The serializer settings used when deserializing the event body.</param>
/// <param name="etag">The ETag of the event.</param>
/// <returns></returns>
public static IEvent DeserializeEvent(string aggregateName,
string eventName,
Guid aggregateId,
long sequenceNumber,
DateTimeOffset timestamp,
string body,
dynamic uniqueEventId = null,
JsonSerializerSettings serializerSettings = null,
string etag = null)
{
var deserializerKey = aggregateName + ":" + eventName;
var @event = deserializers.GetOrAdd(deserializerKey, _ =>
{
var aggregateType = AggregateType.KnownTypes.SingleOrDefault(t => t.Name == aggregateName);
if (aggregateType != null)
{
serializerSettings = serializerSettings ?? Settings;
IEnumerable <Type> eventTypes = typeof(Event <>).MakeGenericType(aggregateType).Member().KnownTypes;
// some events contain specialized names, e.g. CommandScheduled:DoSomething. the latter portion is not interesting from a serialization standpoint, so we strip it off.
eventName = eventName.Split(':').First();
var eventType = eventTypes.SingleOrDefault(t =>
t.GetCustomAttributes(false)
.OfType <EventNameAttribute>()
.FirstOrDefault()
.IfNotNull()
.Then(
att => att.EventName == eventName)
.Else(() =>
// strip off generic specifications from the type name
t.Name.Split('`').First() == eventName));
if (eventType != null)
{
return(e =>
{
var deserializedEvent = (IEvent)JsonConvert.DeserializeObject(e.Body, eventType, serializerSettings);
var dEvent = deserializedEvent as Event;
if (dEvent != null)
{
dEvent.AggregateId = e.AggregateId;
dEvent.SequenceNumber = e.SequenceNumber;
dEvent.Timestamp = e.Timestamp;
dEvent.ETag = e.ETag;
}
return deserializedEvent;
});
}
// even if the domain no longer cares about some old event type, anonymous events are returned as placeholders in the EventSequence
eventType = typeof(AnonymousEvent <>).MakeGenericType(aggregateType);
return(e =>
{
var anonymousEvent = (Event)JsonConvert.DeserializeObject(e.Body, eventType, serializerSettings);
anonymousEvent.AggregateId = e.AggregateId;
anonymousEvent.SequenceNumber = e.SequenceNumber;
anonymousEvent.Timestamp = e.Timestamp;
anonymousEvent.ETag = e.ETag;
((dynamic)anonymousEvent).Body = e.Body;
return anonymousEvent;
});
}
return(e =>
{
dynamic deserializeObject = JsonConvert.DeserializeObject(e.Body, serializerSettings);
var dynamicEvent = new DynamicEvent(deserializeObject)
{
EventStreamName = e.StreamName,
EventTypeName = e.EventTypeName,
AggregateId = e.AggregateId,
SequenceNumber = e.SequenceNumber,
Timestamp = e.Timestamp,
ETag = e.ETag
};
return dynamicEvent;
});
})(new StoredEvent
{
StreamName = aggregateName,
EventTypeName = eventName,
Body = body,
AggregateId = aggregateId,
SequenceNumber = sequenceNumber,
Timestamp = timestamp,
ETag = etag
});
if (uniqueEventId != null)
{
@event.IfTypeIs <IHaveExtensibleMetada>()
.Then(e => e.Metadata.AbsoluteSequenceNumber = uniqueEventId);
}
return(@event);
}
