public async Task <int> AddJobAsync(Job2Dto job2Dto) { _logger.LogInformation("Incoming Dto {0}", job2Dto); string currentUsername = GetCurrentUserEmail(); var job = _mapper.Map <Job>(job2Dto.Job); if (job != null) { JobCreatedIntegrationEvent jobCreatedEvent = null; await ResilientTransaction.New(_dbContext).ExecuteAsync(async() => { job.TransfereeId = SaveTransferee(job2Dto.Transferee); job.AccountEntity = _dbContext.AccountEntity.FirstOrDefault(a => a.Id == job.AccountEntityId); var dateTimeAdded = DateTime.UtcNow; job.DateCreated = dateTimeAdded; job.DateModified = dateTimeAdded; job.CreatedBy = GetCurrentUserEmail(); job.ModifiedBy = GetCurrentUserEmail(); if (job2Dto.Job.IsSurveyAndBid) { job.JobStatus = JobStatusIdentifier.SURVEY_BID; } _dbContext.Job.Attach(job); _dbContext.Entry(job).State = EntityState.Added; await _dbContext.SaveChangesAsync(); //update the fks in the job table var kvp = await SaveAddresses(job2Dto.JobInfo); job.OriginAddressId = kvp.FirstOrDefault(s => s.Key == AddressType.ORIGIN).Value; job.DestinationAddressId = kvp.FirstOrDefault(s => s.Key == AddressType.DESTINATION).Value; await _dbContext.SaveChangesAsync(); jobCreatedEvent = job.FromJob <JobCreatedIntegrationEvent>(); jobCreatedEvent.Transferee = job2Dto.ToTransfereeIntegrationEvent <TransfereeCreatedIntegrationEvent>(); jobCreatedEvent.UserId = GetJobsMoveConsultantEmail(job.Id); await _eventLogService.SaveEventAsync(jobCreatedEvent); }); // Publish the integration event through the event bus _eventBus.Publish(jobCreatedEvent); await _eventLogService.MarkEventAsPublishedAsync(jobCreatedEvent.Id); _logger.LogInformation("Job added {0}", job.Id); } return(job.Id); }
private async Task PublishPendingIntegrationEvents(CancellationToken cancellationToken) { var pendingLogEvents = await _eventLogService .RetrieveScopedEventsPendingToPublishAsync(); foreach (var logEvt in pendingLogEvents) { try { await _eventLogService.MarkEventAsInProgressAsync(logEvt.EventId); _logger.LogInformation("----- Publishing integration event: {IntegrationEventId}", logEvt.EventId); await _eventsPublisher.Publish(logEvt.IntegrationEvent, cancellationToken); _logger.LogInformation("----- Published integration event: {IntegrationEventId}", logEvt.EventId); await _eventLogService.MarkEventAsPublishedAsync(logEvt.EventId); } catch (Exception ex) { _logger.LogError(ex, "ERROR publishing integration event: {IntegrationEventId}", logEvt.EventId); await _eventLogService.MarkEventAsFailedAsync(logEvt.EventId); } } }
public async Task PublishEventsThroughEventBusAsync(Guid transactionId) { var pendingLogEvents = await _eventLogService.RetrieveEventLogsPendingToPublishAsync(transactionId); foreach (var logEvt in pendingLogEvents) { _logger.LogInformation( "----- Publishing integration event: {IntegrationEventId} - ({@IntegrationEvent})", logEvt.Id, logEvt.IntegrationEvent); try { await _eventLogService.MarkEventAsInProgressAsync(logEvt.Id); _eventBus.Publish(logEvt.IntegrationEvent); await _eventLogService.MarkEventAsPublishedAsync(logEvt.Id); } catch (Exception ex) { _logger.LogError(ex, "ERROR publishing integration event: {IntegrationEventId}", logEvt.Id); await _eventLogService.MarkEventAsFailedAsync(logEvt.Id); } } }
public async Task PublishThroughEventBusAsync(IntegrationEvent evt) { await SaveEventAndOrderingContextChangesAsync(evt); _eventBus.Publish(evt); await _eventLogService.MarkEventAsPublishedAsync(evt); }
/// <summary> /// Fetches any pending events from the current transaction and publishes these through the event bus one by one. /// Each event passes through several states, making it easier to track when and if an event fails to be published. /// If any failures are detected, publishing that event will NOT be retried (no logic for handling this exists at this point). /// </summary> /// <param name="transactionId">The transaction id of the DbContextTransaction the given events where created during.</param> public async Task PublishEventsThroughEventBusAsync(Guid transactionId) { var pendingEvents = await _integrationEventLogService.RetrieveEventLogsPendingToPublishAsync(transactionId); foreach (var logEvent in pendingEvents) { try { await _integrationEventLogService.MarkEventAsInProgressAsync(logEvent.EventId); _logger.LogDebug("Event {0} status marked as in progress.", logEvent.EventId); await _eventBus.Publish(logEvent.IntegrationEvent, logEvent.EventType); _logger.LogDebug("Published event {0} with content: {1}", logEvent.EventId, logEvent.Content); await _integrationEventLogService.MarkEventAsPublishedAsync(logEvent.EventId); _logger.LogDebug("Event {0} status marked as published.", logEvent.EventId); } catch (Exception ex) { await _integrationEventLogService.MarkEventAsFailedAsync(logEvent.EventId); _logger.LogError(ex, "Event {0} status marked as failed", logEvent.EventId); } } }
/// <summary> /// Publish the events through the event bus async /// </summary> /// <param name="transactionId"></param> /// <returns></returns> public async Task PublishEventsThroughEventBusAsync(Guid transactionId) { // Retrieve all the pending events to be published var pendingLogEvents = await _eventLogService.RetrieveEventLogsPendingToPublishAsync(transactionId); // Loop through each integration event foreach (var logEvt in pendingLogEvents) { // Log publishing the event _logger.LogInformation("----- Publishing integration event: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", logEvt.EventId, Program.AppName, logEvt.IntegrationEvent); try { // Mark the event as in progress await _eventLogService.MarkEventAsInProgressAsync(logEvt.EventId); // Publish the event _eventBus.Publish(logEvt.IntegrationEvent); // Mark the event as published await _eventLogService.MarkEventAsPublishedAsync(logEvt.EventId); } catch (Exception ex) { // In case of exception, log the exception _logger.LogError(ex, "ERROR publishing integration event: {IntegrationEventId} from {AppName}", logEvt.EventId, Program.AppName); // Mark the event as failed await _eventLogService.MarkEventAsFailedAsync(logEvt.EventId); } } }
/// <summary> /// 通过事件总线发布事件 /// </summary> /// <param name="evt">事件</param> /// <returns></returns> public async Task PublishThroughEventBusAsync(IntegrationEvent evt) { //001.发布事件 _eventBus.Publish(evt); //002.标志事件为已发布 await _eventLogService.MarkEventAsPublishedAsync(evt); }
public async Task <ActionResult> DeleteAsync(long id) { var room = await roomRepository.GetByIdAsync(id); if (room == null) { return(NotFound(new ErrorDTO { ErrorMessage = "Room does not exist" })); } var roomDeletedEvent = new RoomDeletedEvent(room.Id); using (var transaction = session.BeginTransaction()) { await roomRepository.DeleteAsync(id); await integrationEventLogService.SaveEventAsync(roomDeletedEvent); transaction?.Commit(); } // Publish integration event: RoomDeletedEvent using (var transaction = session.BeginTransaction()) { eventBus.Publish(roomDeletedEvent); await integrationEventLogService.MarkEventAsPublishedAsync(roomDeletedEvent.EventId); transaction?.Commit(); } return(NoContent()); }
public async Task PublishThroughEventBusAsync(IEvent evt) { await SaveEventAndBusinessDbContextChangesAsync(evt); await _eventBus.Publish(evt); await _eventLogService.MarkEventAsPublishedAsync(evt); }
public Task PublishThroughEventBusAsync(IEvent evt) { Task[] tasks = new Task[3]; //tasks[0] = _eventLogService.SaveEventAsync(evt, _context.Database.CurrentTransaction.GetDbTransaction()); tasks[1] = _eventBus.Publish(evt); tasks[2] = _eventLogService.MarkEventAsPublishedAsync(evt); return(Task.WhenAll(tasks)); }
public async Task <ActionResult> UpdateProductAsync([FromBody] CatalogItem productToUpdate) { var catalogItem = await _catalogContext.CatalogItems.SingleOrDefaultAsync(i => i.Id == productToUpdate.Id); if (catalogItem == null) { return(NotFound(new { Message = $"Item with id {productToUpdate.Id} not found." })); } var oldPrice = catalogItem.Price; var raiseProductPriceChangedEvent = oldPrice != productToUpdate.Price; // Update current product catalogItem = productToUpdate; _catalogContext.CatalogItems.Update(catalogItem); if (raiseProductPriceChangedEvent) // Save product's data and publish integration event through the Event Bus if price has changed { _logger.LogInformation(" [x] CatalogController.UpdateProduct(): Price has changed, integration event is being prepared..."); var productPriceChangeEvent = new ProductPriceChangedIntegrationEvent(productToUpdate.Id, oldPrice, productToUpdate.Price); var strategy = _catalogContext.Database.CreateExecutionStrategy(); _logger.LogInformation(" [x] CatalogController.UpdateProductAsync(): Beginning new transaction to save event and commit changes."); await strategy.Execute(async() => { using (var transaction = _catalogContext.Database.BeginTransaction()) { await _eventLogService.SaveEventAsync(productPriceChangeEvent, transaction); await _catalogContext.SaveChangesAsync(); transaction.Commit(); _logger.LogInformation(" [x] CatalogController.UpdateProductAsync(): Transaction ({0}) has been committed.", transaction.TransactionId); } }); try { await _eventLogService.MarkEventAsInProgressAsync(productPriceChangeEvent.Id); _eventBus.Publish(productPriceChangeEvent); await _eventLogService.MarkEventAsPublishedAsync(productPriceChangeEvent.Id); } catch (Exception e) { _logger.LogError(e, " [x] CatalogController.UpdateProductAsync(): Fail when publishing integration event {0}.", productPriceChangeEvent.Id); await _eventLogService.MarkEventAsFailedAsync(productPriceChangeEvent.Id); } } else // Just save the updated product because the Product's Price hasn't changed. { await _catalogContext.SaveChangesAsync(); } return(Ok()); }
public async Task PublishThroughEventBusAsync(IntegrationEvent evt) { try { await _eventLogService.MarkEventAsInProgressAsync(evt.Id); _eventBus.Publish(evt); await _eventLogService.MarkEventAsPublishedAsync(evt.Id); } catch (Exception) { await _eventLogService.MarkEventAsFailedAsync(evt.Id); } }
public async Task PublishThroughEventBusAsync(IntegrationEvent evt) { try { _logger.LogInformation("----- Publishing integration event: {IntegrationEventId_published} from {AppName} - ({@IntegrationEvent})", evt.Id, Program.AppName, evt); await _eventLogService.MarkEventAsInProgressAsync(evt.Id); _eventBus.Publish(evt); await _eventLogService.MarkEventAsPublishedAsync(evt.Id); } catch (Exception ex) { _logger.LogError(ex, "ERROR Publishing integration event: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", evt.Id, Program.AppName, evt); await _eventLogService.MarkEventAsFailedAsync(evt.Id); } }
public async Task PublishEvent(IntegrationEvent @event) { if (_integrationEventLogService.Find(@event.Id) == null) { throw new IntegrationEventWithIdDoesNotExistsException(@event.Id); } try { _eventBus.Publish(@event); await _integrationEventLogService.MarkEventAsPublishedAsync(@event); } catch (FailToSendEventToRabbitException) { await _integrationEventLogService.MarkEventAsFailToPublishAsync(@event); throw; } }
public async Task PublishThroughEventBusAsync(IntegrationEvent @event) { try { await _eventLogService.MarkEventAsInProgressAsync(@event.Id); await _eventBus.PublishAsync(@event); await _eventLogService.MarkEventAsPublishedAsync(@event.Id); _logger.Information($"PublishThroughEventBusAsync {@event}"); } catch (Exception ex) { await _eventLogService.MarkEventAsFailedAsync(@event.Id); _logger.Error($"PublishThroughEventBusAsync erorr {@event}"); } }
public async Task PublishEventsThroughEventBusAsync() { var pendingLogEvents = await _eventLogService.RetrieveEventLogsPendingToPublishAsync(); foreach (var logEvt in pendingLogEvents) { try { await _eventLogService.MarkEventAsInProgressAsync(logEvt.EventId); _eventBus.Publish(logEvt.IntegrationEvent); await _eventLogService.MarkEventAsPublishedAsync(logEvt.EventId); } catch (Exception) { await _eventLogService.MarkEventAsFailedAsync(logEvt.EventId); } } }
public async Task PublishEventsAsync(Guid transactionId) { var pendingEventLogs = await _integrationEventLogService.GetPendingEventLogEntries(transactionId); foreach (var eventLog in pendingEventLogs) { try { await _integrationEventLogService.MarkEventAsInProgressAsync(eventLog.EventId); _eventBus.Publish(eventLog.IntegrationEvent); await _integrationEventLogService.MarkEventAsPublishedAsync(eventLog.EventId); } catch (Exception ex) { Debug.WriteLine("Error publishing"); await _integrationEventLogService.MarkEventAsFailedAsync(eventLog.EventId); } } }
public async Task PublishEventsThroughEventBusAsync() { IEnumerable <IntegrationEventLogEntry> pendingLogEvents = await _eventLogService.RetrieveEventLogsPendingToPublishAsync(); foreach (var logEvt in pendingLogEvents) { try { await _eventLogService.MarkEventAsInProgressAsync(logEvt.EventId); _eventBus.Publish(logEvt.IntegrationEvent); await _eventLogService.MarkEventAsPublishedAsync(logEvt.EventId); } catch (Exception ex) { _logger.LogError(ex, "ERROR publishing integration event: {IntegrationEventId} from ProductService", logEvt.EventId); await _eventLogService.MarkEventAsFailedAsync(logEvt.EventId); } } }
public async Task PublishThroughEventBusAsync(IntegrationEvent evt) { _eventBus.Publish(evt); await _eventLogService.MarkEventAsPublishedAsync(evt); }
public async Task PublishThroughEventBusAsync(Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events.IntegrationEvent evt) { _eventBus.Publish(evt); await _eventLogService.MarkEventAsPublishedAsync(evt); }