protected override void OnReceive(object message)
{
switch (message)
{
case TempReadingMessage m:
if (m.ContainerId != ContainerId)
{
return;
}
// check temp reading
_monitor.Check(new Reading(new Temp(m.Reading), m.Timestamp));
// persist the aggregate
TempRangeMonitorRepo.SaveAsync(_monitor);
// emit any events
EventDispatcher.DispatchAsync(_monitor.Events).Wait();
break;
default:
break;
}
}
public async Task Should_process_event()
{
var dispatcher = new EventDispatcher(ResolverAccessor);
await dispatcher.DispatchAsync(new SomeEvent());
Assert.Pass();
}
public async Task DispatchAsync_ThrowsException_IfListIsEmptyAsync_Test()
{
var mediator = new Mock <IMediator>();
var dut = new EventDispatcher(mediator.Object);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() =>
dut.DispatchAsync(null));
}
public async Task HandleAsync(Command cmd)
{
// restore aggregate's state
var cargo = await CargoRepository.GetAsync(cmd.TrackingId);
// apply command
cargo.ChangeRoute(cmd.RouteSpecification);
// emit events
await EventDispatcher.DispatchAsync(cargo.Events);
// persist state
await CargoRepository.SaveAsync(cargo);
}
public async Task HandleAsync(Command cmd)
{
// restore aggregate's state
var cargo = await CargoRepository.GetAsync(cmd.HandlingEvent.TrackingId);
// apply command
cargo.RegisterHandlingEvent(cmd.HandlingEvent);
// emit events
await EventDispatcher.DispatchAsync(cargo.Events);
// persist state
await CargoRepository.SaveAsync(cargo);
}
public async Task Run([ServiceBusTrigger(QueueName, Connection = ConnectionName)] string message, ILogger log)
{
// Deserialize the EntityMessage
var entityMessage = JsonSerializer.Deserialize <EntityMessage>(message);
// Get the Type of the event from the message
var eventType = Assembly.GetAssembly(typeof(Course)).GetType(entityMessage.Type);
// Deserialize the event from the message and dispatch
var @event = JsonSerializer.Deserialize(entityMessage.Data, eventType);
await EventDispatcher.DispatchAsync(@event as IEvent);
log.LogInformation($"Function {FunctionName} received Service Bus Queue message: {message}");
}
public async Task HandleAsync(Command cmd)
{
// restore aggregate's state
var cargo = await CargoRepository.GetAsync(cmd.TrackingId);
// apply command
cargo.AssignToItinerary(cmd.Itinerary);
// emit events
EventDispatcher.DispatchAsync(cargo.Events);
// persist state
await CargoRepository.SaveAsync(cargo);
}
public async Task DispatchAsync_SendsOutEvents_Test()
{
var mediator = new Mock <IMediator>();
var dut = new EventDispatcher(mediator.Object);
var entities = new List <TestableEntityBase>();
for (var i = 0; i < 3; i++)
{
var entity = new Mock <TestableEntityBase>();
entity.Object.AddDomainEvent(new Mock <INotification>().Object);
entities.Add(entity.Object);
}
await dut.DispatchAsync(entities, default);
mediator.Verify(x => x.Publish(It.IsAny <INotification>(), It.IsAny <CancellationToken>()), Times.Exactly(3));
}
private async Task <bool> AttemptToResolveEventAsync <TEventHandler, TEvent, TEventOutput>(INetworkBlockHeader blockHeader, GameRoundId gameRoundId, CancellationToken cancellationToken)
where TEventHandler : IEventHandler <TEventOutput> where TEvent : Event <TEventOutput>, new() where TEventOutput : EventOutput
{
TEvent evt = this._contractInfo.Event <TEvent>();
EventSignature eventSignature = this._eventSignatureFactory.Create(evt);
IReadOnlyList <TransactionHash> transactionHashes = await this._gameRoundDataManager.GetTransactionsAsync(gameRoundId : gameRoundId, functionName : evt.Name);
IReadOnlyList <IPendingNetworkTransaction> transactions =
await this._transactionLoader.GetTransactionsAsync(network : blockHeader.Network, transactionHashes : transactionHashes, cancellationToken : cancellationToken);
IReadOnlyList <NetworkTransactionReceipt> receipts =
await this._transactionLoader.GetTransactionReceiptsAsync(network : blockHeader.Network, transactionHashes : transactionHashes, cancellationToken : cancellationToken);
bool handled = false;
foreach (NetworkTransactionReceipt?receipt in receipts)
{
IPendingNetworkTransaction transaction = transactions.First(tx => tx.TransactionHash == receipt.TransactionHash);
IReadOnlyList <TransactionEventLogEntry> logs = receipts.SelectMany(r => r.Logs?.Where(l => l.Topics[0]
.ToEventSignature() == eventSignature) ?? Array.Empty <TransactionEventLogEntry>())
.ToArray();
IEventDispatcher ed = new EventDispatcher <TEventHandler, TEvent, TEventOutput>(contractInfo: this._contractInfo,
eventSignature: eventSignature,
eventHandlerFactory: this._eventHandlerFactory,
eventDataManager: this._eventDataManager,
eventDecoder: this._eventDecoder,
confirmationsReadinessChecker: this._confirmationsReadinessChecker,
logger: this._logger);
handled |= await ed.DispatchAsync(network : blockHeader.Network,
logs : logs,
networkBlockHeader : blockHeader,
latestBlockNumberOnNetwork : blockHeader.Number,
isFresh : false,
gasUsed : receipt.GasUsed,
gasPrice : transaction.GasPrice,
retrievalStrategy : EventRetrievalStrategy.RISKY);
}
return(handled);
}
public async Task <IActionResult> RequestSessionAsync([FromServices] RequestSessionCommandHandler handler, [FromBody] RequestSessionModel requestSessionModel, CancellationToken cancellationToken)
{
var command = new RequestSession(
new List <PersonId>(requestSessionModel.Speakers.Select(g => (PersonId)g)),
requestSessionModel.Title,
requestSessionModel.Description,
requestSessionModel.Tags,
requestSessionModel.StartTime,
requestSessionModel.EndTime);
var(result, events) = await handler.ExecuteAsync(command, cancellationToken);
await _eventDispatcher.DispatchAsync(events);
return(result switch
{
SuccessCommandResult src => Accepted(),
ValidationFailureCommandResult vfcr => this.ValidationProblem(vfcr),
FailureCommandResult fcr => this.Problem(fcr),
_ => Problem()
});
public static async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
IEvent @event;
if (message.ContentType == typeof(CustomerCreatedEvent).Name)
{
@event = JsonConvert.DeserializeObject <CustomerCreatedEvent>(Encoding.UTF8.GetString(message.Body));
}
else if (message.ContentType == typeof(CustomerVerifiedAsEligibleEvent).Name)
{
@event = JsonConvert.DeserializeObject <CustomerVerifiedAsEligibleEvent>(Encoding.UTF8.GetString(message.Body));
}
else
{
throw new NotSupportedException($"Event {message.ContentType} is not supported");
}
await _dispatcher.DispatchAsync(@event).ConfigureAwait(false);
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
}
