/// <summary>
/// Deserialize the json object but swallow errors and return null on error.
/// </summary>
/// <param name="aggregateId"></param>
/// <param name="json"></param>
/// <param name="metadata"></param>
/// <returns></returns>
private IDomainEvent Deserialize(string aggregateId, string json, IMetadata metadata)
{
try
{
var eventDefinition = _eventDefinitionService.GetDefinition(
metadata.EventName,
metadata.EventVersion);
var aggregateEvent = (IAggregateEvent)_jsonSerializer.Deserialize(json, eventDefinition.Type);
var domainEvent = _domainEventFactory.Create(
aggregateEvent,
metadata,
aggregateId,
metadata.AggregateSequenceNumber);
_log.Verbose(() =>
$"Deserialize { metadata.EventName} events at time stamp { metadata.Timestamp.DateTime}");
return(domainEvent);
}
catch
{
return(null);
}
}
private void OnReceived(Object sender, BasicDeliverEventArgs e)
{
try
{
var message = _rabbitMqMessageFactory.Create(e);
var eventMetadata = new EventMetadata(message.Headers.ToDictionary(kv => kv.Key, kv => Encoding.UTF8.GetString((Byte[])kv.Value)));
var eventDefinition = _applicationDefinition.Events.GetDefinition(eventMetadata.EventName, eventMetadata.EventVersion);
if (eventDefinition == null)
{
_channel.BasicAck(e.DeliveryTag, false);
return;
}
var aggregateEvent = (IAggregateEvent)JsonConvert.DeserializeObject(message.Message, eventDefinition.Type);
var domainEvent = _domainEventFactory.Create(aggregateEvent, eventMetadata);
_domainEventBus.Publish(domainEvent);
}
catch
{
if (_connection.IsOpen)
{
_channel.BasicNack(e.DeliveryTag, false, false);
}
}
if (_connection.IsOpen)
{
_channel.BasicAck(e.DeliveryTag, false);
}
}
private IDomainEvent Deserialize(string aggregateId, string json, IMetadata metadata)
{
var eventDefinition = _eventDefinitionService.GetDefinition(
metadata.EventName,
metadata.EventVersion);
var aggregateEvent = (IAggregateEvent)_jsonSerializer.Deserialize(json, eventDefinition.Type);
var domainEvent = _domainEventFactory.Create(
aggregateEvent,
metadata,
aggregateId,
metadata.AggregateSequenceNumber);
return(domainEvent);
}
public async Task <ActionResult> Post([FromBody] int value)
{
var exampleId = ExampleId.New;
var multiplierEvent =
_domainEventFactory.Create(new AnotherExampleEvent(value), new Metadata
{
AggregateId = exampleId.Value,
Timestamp = DateTime.UtcNow
}, exampleId.Value, 1);
// The publishAsync api call does not persist the event to the EventFlow table.
await _domainEventPublisher.PublishAsync(new List <IDomainEvent> {
multiplierEvent
}, CancellationToken.None);
return(CreatedAtAction(nameof(GetExample), new { id = exampleId.Value }, multiplierEvent));
}
protected IDomainEvent <CompetitionAggregate, CompetitionId> ToDomainEvent(
CompetitionId competitionId,
IAggregateEvent aggregateEvent,
int aggregateSequenceNumber = 1)
{
var metadata = new Metadata
{
Timestamp = A <DateTimeOffset>(),
SourceId = A <SourceId>(),
};
return(DomainEventFactory.Create <CompetitionAggregate, CompetitionId>(
aggregateEvent,
metadata,
competitionId,
aggregateSequenceNumber));
}
public IDomainEvent Deserialize(ICommittedDomainEvent committedDomainEvent)
{
var metadata = (IMetadata)_jsonSerializer.Deserialize <Metadata>(committedDomainEvent.Metadata);
var eventDefinition = _eventDefinitionService.GetEventDefinition(
metadata.EventName,
metadata.EventVersion);
var aggregateEvent = (IAggregateEvent)_jsonSerializer.Deserialize(committedDomainEvent.Data, eventDefinition.Type);
var domainEvent = _domainEventFactory.Create(
aggregateEvent,
metadata,
committedDomainEvent.AggregateId,
committedDomainEvent.AggregateSequenceNumber);
return(domainEvent);
}
protected IDomainEvent <TestAggregate, TestId> ToDomainEvent <TAggregateEvent>(
TAggregateEvent aggregateEvent,
int aggregateSequenceNumber = 0)
where TAggregateEvent : IAggregateEvent
{
var metadata = new Metadata
{
Timestamp = A <DateTimeOffset>()
};
if (aggregateSequenceNumber == 0)
{
aggregateSequenceNumber = A <int>();
}
return(DomainEventFactory.Create <TestAggregate, TestId>(
aggregateEvent,
metadata,
A <TestId>(),
aggregateSequenceNumber));
}
protected IDomainEvent <ThingyAggregate, ThingyId> ToDomainEvent <TAggregateEvent>(
ThingyId thingyId,
TAggregateEvent aggregateEvent,
int aggregateSequenceNumber = 0)
where TAggregateEvent : IAggregateEvent
{
var metadata = new Metadata
{
Timestamp = A <DateTimeOffset>(),
SourceId = A <SourceId>(),
};
if (aggregateSequenceNumber == 0)
{
aggregateSequenceNumber = A <int>();
}
return(DomainEventFactory.Create <ThingyAggregate, ThingyId>(
aggregateEvent,
metadata,
thingyId,
aggregateSequenceNumber));
}
