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); }