Send IntegrationEvents after committing transactions

Ramón Tomás · Ramón Tomás · commit 24bed0aa33a9 · 2018-10-11T17:16:31.000+02:00
diff --git a/src/BuildingBlocks/EventBus/EventBusRabbitMQ/EventBusRabbitMQ.cs b/src/BuildingBlocks/EventBus/EventBusRabbitMQ/EventBusRabbitMQ.cs
@@ -217,14 +217,16 @@ private async Task ProcessEvent(string eventName, string message)
                         if (subscription.IsDynamic)
                         { 
                             var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;
+                            if (handler == null) continue;
                             dynamic eventData = JObject.Parse(message);
                             await handler.Handle(eventData);
                         }
                         else
                         {
+                            var handler = scope.ResolveOptional(subscription.HandlerType);
+                            if (handler == null) continue;
                             var eventType = _subsManager.GetEventTypeByName(eventName);
                             var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
-                            var handler = scope.ResolveOptional(subscription.HandlerType);
                             var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType);
                             await (Task)concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
                         }
diff --git a/src/BuildingBlocks/EventBus/EventBusServiceBus/EventBusServiceBus.cs b/src/BuildingBlocks/EventBus/EventBusServiceBus/EventBusServiceBus.cs
@@ -163,14 +163,16 @@ private async Task<bool> ProcessEvent(string eventName, string message)
                         if (subscription.IsDynamic)
                         {
                             var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;
+                            if (handler == null) continue;
                             dynamic eventData = JObject.Parse(message);
                             await handler.Handle(eventData);
                         }
                         else
                         {
-                            var eventType = _subsManager.GetEventTypeByName(eventName);
-                            var integrationEvent = JsonConvert.DeserializeObject(message, eventType);
                             var handler = scope.ResolveOptional(subscription.HandlerType);
+                            if (handler == null) continue;
+                            var eventType = _subsManager.GetEventTypeByName(eventName);
+                            var integrationEvent = JsonConvert.DeserializeObject(message, eventType);                            
                             var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType);
                             await (Task)concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });
                         }
diff --git a/src/BuildingBlocks/EventBus/IntegrationEventLogEF/EventStateEnum.cs b/src/BuildingBlocks/EventBus/IntegrationEventLogEF/EventStateEnum.cs
@@ -7,7 +7,8 @@ namespace Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF
     public enum EventStateEnum
     {
         NotPublished = 0,
-        Published = 1,
-        PublishedFailed = 2
+        InProgress = 1,
+        Published = 2,
+        PublishedFailed = 3
     }
 }
diff --git a/src/BuildingBlocks/EventBus/IntegrationEventLogEF/IntegrationEventLogEntry.cs b/src/BuildingBlocks/EventBus/IntegrationEventLogEF/IntegrationEventLogEntry.cs
@@ -3,6 +3,8 @@
 using System.Text;
 using Newtonsoft.Json;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
+using System.Linq;
+using System.ComponentModel.DataAnnotations.Schema;
 
 namespace Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF
 {
@@ -11,7 +13,7 @@ public class IntegrationEventLogEntry
         private IntegrationEventLogEntry() { }
         public IntegrationEventLogEntry(IntegrationEvent @event)
         {
-            EventId = @event.Id;
+            EventId = @event.Id;            
             CreationTime = @event.CreationDate;
             EventTypeName = @event.GetType().FullName;
             Content = JsonConvert.SerializeObject(@event);
@@ -20,9 +22,18 @@ public IntegrationEventLogEntry(IntegrationEvent @event)
         }
         public Guid EventId { get; private set; }
         public string EventTypeName { get; private set; }
+        [NotMapped]
+        public string EventTypeShortName => EventTypeName.Split('.')?.Last();
+        [NotMapped]
+        public IntegrationEvent IntegrationEvent { get; private set; }
         public EventStateEnum State { get; set; }
         public int TimesSent { get; set; }
         public DateTime CreationTime { get; private set; }
         public string Content { get; private set; }
+
+        public void DeserializeJsonContent(Type type)
+        {
+            IntegrationEvent = JsonConvert.DeserializeObject(Content, type) as IntegrationEvent;
+        }
     }
 }
diff --git a/src/BuildingBlocks/EventBus/IntegrationEventLogEF/Services/IIntegrationEventLogService.cs b/src/BuildingBlocks/EventBus/IntegrationEventLogEF/Services/IIntegrationEventLogService.cs
@@ -9,7 +9,10 @@ namespace Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF.Servi
 {
     public interface IIntegrationEventLogService
     {
+        Task<IEnumerable<IntegrationEventLogEntry>> RetrieveEventLogsPendingToPublishAsync();
         Task SaveEventAsync(IntegrationEvent @event, DbTransaction transaction);
-        Task MarkEventAsPublishedAsync(IntegrationEvent @event);
+        Task MarkEventAsPublishedAsync(Guid eventId);
+        Task MarkEventAsInProgressAsync(Guid eventId);
+        Task MarkEventAsFailedAsync(Guid eventId);
     }
 }
diff --git a/src/BuildingBlocks/EventBus/IntegrationEventLogEF/Services/IntegrationEventLogService.cs b/src/BuildingBlocks/EventBus/IntegrationEventLogEF/Services/IntegrationEventLogService.cs
@@ -1,7 +1,11 @@
 ﻿using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.eShopOnContainers.BuildingBlocks.EventBus;
 using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
+using Newtonsoft.Json;
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Data.Common;
 using System.Linq;
 using System.Threading.Tasks;
@@ -10,19 +14,35 @@ namespace Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF.Servi
 {
     public class IntegrationEventLogService : IIntegrationEventLogService
     {
+        private readonly IEventBusSubscriptionsManager _subsManager;
         private readonly IntegrationEventLogContext _integrationEventLogContext;
         private readonly DbConnection _dbConnection;
 
-        public IntegrationEventLogService(DbConnection dbConnection)
+        public IntegrationEventLogService(IEventBusSubscriptionsManager subsManager, 
+            DbConnection dbConnection)
         {
             _dbConnection = dbConnection ?? throw new ArgumentNullException(nameof(dbConnection));
+            _subsManager = subsManager ?? throw new ArgumentNullException(nameof(subsManager));
             _integrationEventLogContext = new IntegrationEventLogContext(
                 new DbContextOptionsBuilder<IntegrationEventLogContext>()
                     .UseSqlServer(_dbConnection)
                     .ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning))
                     .Options);
         }
 
+        public async Task<IEnumerable<IntegrationEventLogEntry>> RetrieveEventLogsPendingToPublishAsync()
+        {
+            var eventLogsPendingToPublish = await _integrationEventLogContext.IntegrationEventLogs
+                .Where(e => e.State == EventStateEnum.NotPublished)
+                .OrderBy(o => o.CreationTime)
+                .ToListAsync();
+
+            eventLogsPendingToPublish.ForEach(evtLog => 
+                evtLog.DeserializeJsonContent(_subsManager.GetEventTypeByName(evtLog.EventTypeShortName)));                
+
+          return eventLogsPendingToPublish;
+        }
+
         public Task SaveEventAsync(IntegrationEvent @event, DbTransaction transaction)
         {
             if (transaction == null)
@@ -38,11 +58,28 @@ public Task SaveEventAsync(IntegrationEvent @event, DbTransaction transaction)
             return _integrationEventLogContext.SaveChangesAsync();
         }
 
-        public Task MarkEventAsPublishedAsync(IntegrationEvent @event)
+        public Task MarkEventAsPublishedAsync(Guid eventId)
+        {
+            return UpdateEventStatus(eventId, EventStateEnum.Published);
+        }
+
+        public Task MarkEventAsInProgressAsync(Guid eventId)
         {
-            var eventLogEntry = _integrationEventLogContext.IntegrationEventLogs.Single(ie => ie.EventId == @event.Id);
-            eventLogEntry.TimesSent++;
-            eventLogEntry.State = EventStateEnum.Published;
+            return UpdateEventStatus(eventId, EventStateEnum.InProgress);
+        }
+
+        public Task MarkEventAsFailedAsync(Guid eventId)
+        {
+            return UpdateEventStatus(eventId, EventStateEnum.PublishedFailed);
+        }
+
+        private Task UpdateEventStatus(Guid eventId, EventStateEnum status)
+        {
+            var eventLogEntry = _integrationEventLogContext.IntegrationEventLogs.Single(ie => ie.EventId == eventId);
+            eventLogEntry.State = status;
+
+            if(status == EventStateEnum.InProgress)
+                eventLogEntry.TimesSent++;
 
             _integrationEventLogContext.IntegrationEventLogs.Update(eventLogEntry);
 
diff --git a/src/Services/Catalog/Catalog.API/IntegrationEvents/CatalogIntegrationEventService.cs b/src/Services/Catalog/Catalog.API/IntegrationEvents/CatalogIntegrationEventService.cs
@@ -29,9 +29,16 @@ public CatalogIntegrationEventService(IEventBus eventBus, CatalogContext catalog
 
         public async Task PublishThroughEventBusAsync(IntegrationEvent evt)
         {
-            _eventBus.Publish(evt);
-
-            await _eventLogService.MarkEventAsPublishedAsync(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 SaveEventAndCatalogContextChangesAsync(IntegrationEvent evt)
diff --git a/src/Services/Catalog/Catalog.API/Startup.cs b/src/Services/Catalog/Catalog.API/Startup.cs
@@ -232,7 +232,11 @@ public static IServiceCollection AddSwagger(this IServiceCollection services)
         public static IServiceCollection AddIntegrationServices(this IServiceCollection services, IConfiguration configuration)
         {
             services.AddTransient<Func<DbConnection, IIntegrationEventLogService>>(
-               sp => (DbConnection c) => new IntegrationEventLogService(c));
+               sp => 
+               {
+                   var busMgr = sp.GetRequiredService<IEventBusSubscriptionsManager>();
+                   return (DbConnection c) => new IntegrationEventLogService(busMgr, c);
+               });
 
             services.AddTransient<ICatalogIntegrationEventService, CatalogIntegrationEventService>();
 
diff --git a/src/Services/Ordering/Ordering.API/Application/Behaviors/TransactionBehaviour.cs b/src/Services/Ordering/Ordering.API/Application/Behaviors/TransactionBehaviour.cs
@@ -2,6 +2,7 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.eShopOnContainers.Services.Ordering.Infrastructure;
 using Microsoft.Extensions.Logging;
+using Ordering.API.Application.IntegrationEvents;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -14,10 +15,14 @@ public class TransactionBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequ
     {
         private readonly ILogger<TransactionBehaviour<TRequest, TResponse>> _logger;
         private readonly OrderingContext _dbContext;
+        private readonly IOrderingIntegrationEventService _orderingIntegrationEventService;
 
-        public TransactionBehaviour(OrderingContext dbContext, ILogger<TransactionBehaviour<TRequest, TResponse>> logger)
+        public TransactionBehaviour(OrderingContext dbContext,
+            IOrderingIntegrationEventService orderingIntegrationEventService,
+            ILogger<TransactionBehaviour<TRequest, TResponse>> logger)
         {
             _dbContext = dbContext ?? throw new ArgumentException(nameof(OrderingContext));
+            _orderingIntegrationEventService = orderingIntegrationEventService ?? throw new ArgumentException(nameof(orderingIntegrationEventService));
             _logger = logger ?? throw new ArgumentException(nameof(ILogger));
         }
 
@@ -39,6 +44,8 @@ await strategy.ExecuteAsync(async () =>
                     await _dbContext.CommitTransactionAsync();
 
                     _logger.LogInformation($"Committed transaction {typeof(TRequest).Name}");
+
+                    await _orderingIntegrationEventService.PublishEventsThroughEventBusAsync();
                 });
 
                 return response;
diff --git a/src/Services/Ordering/Ordering.API/Application/Commands/CreateOrderCommandHandler.cs b/src/Services/Ordering/Ordering.API/Application/Commands/CreateOrderCommandHandler.cs
@@ -1,6 +1,8 @@
 ﻿namespace Microsoft.eShopOnContainers.Services.Ordering.API.Application.Commands
 {
     using Domain.AggregatesModel.OrderAggregate;
+    using global::Ordering.API.Application.IntegrationEvents;
+    using global::Ordering.API.Application.IntegrationEvents.Events;
     using MediatR;
     using Microsoft.eShopOnContainers.Services.Ordering.API.Infrastructure.Services;
     using Microsoft.eShopOnContainers.Services.Ordering.Infrastructure.Idempotency;
@@ -15,17 +17,26 @@ public class CreateOrderCommandHandler
         private readonly IOrderRepository _orderRepository;
         private readonly IIdentityService _identityService;
         private readonly IMediator _mediator;
+        private readonly IOrderingIntegrationEventService _orderingIntegrationEventService;
 
         // Using DI to inject infrastructure persistence Repositories
-        public CreateOrderCommandHandler(IMediator mediator, IOrderRepository orderRepository, IIdentityService identityService)
+        public CreateOrderCommandHandler(IMediator mediator,
+            IOrderingIntegrationEventService orderingIntegrationEventService,
+            IOrderRepository orderRepository, 
+            IIdentityService identityService)
         {
             _orderRepository = orderRepository ?? throw new ArgumentNullException(nameof(orderRepository));
             _identityService = identityService ?? throw new ArgumentNullException(nameof(identityService));
             _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
+            _orderingIntegrationEventService = orderingIntegrationEventService ?? throw new ArgumentNullException(nameof(orderingIntegrationEventService));
         }
 
         public async Task<bool> Handle(CreateOrderCommand message, CancellationToken cancellationToken)
         {
+            // Add Integration event to clean the basket
+            var orderStartedIntegrationEvent = new OrderStartedIntegrationEvent(message.UserId);
+            await _orderingIntegrationEventService.AddAndSaveEventAsync(orderStartedIntegrationEvent);
+            
             // Add/Update the Buyer AggregateRoot
             // DDD patterns comment: Add child entities and value-objects through the Order Aggregate-Root
             // methods and constructor so validations, invariants and business logic 
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderCancelled/OrderCancelledDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderCancelled/OrderCancelledDomainEventHandler.cs
@@ -41,7 +41,7 @@ public async Task Handle(OrderCancelledDomainEvent orderCancelledDomainEvent, Ca
             var buyer = await _buyerRepository.FindByIdAsync(order.GetBuyerId.Value.ToString());
 
             var orderStatusChangedToCancelledIntegrationEvent = new OrderStatusChangedToCancelledIntegrationEvent(order.Id, order.OrderStatus.Name, buyer.Name);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedToCancelledIntegrationEvent);
+            await _orderingIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedToCancelledIntegrationEvent);
         }
     }
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderGracePeriodConfirmed/OrderStatusChangedToAwaitingValidationDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderGracePeriodConfirmed/OrderStatusChangedToAwaitingValidationDomainEventHandler.cs
@@ -46,7 +46,7 @@ public async Task Handle(OrderStatusChangedToAwaitingValidationDomainEvent order
 
             var orderStatusChangedToAwaitingValidationIntegrationEvent = new OrderStatusChangedToAwaitingValidationIntegrationEvent(
                 order.Id, order.OrderStatus.Name, buyer.Name, orderStockList);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedToAwaitingValidationIntegrationEvent);
+            await _orderingIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedToAwaitingValidationIntegrationEvent);
         }
     }  
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderPaid/OrderStatusChangedToPaidDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderPaid/OrderStatusChangedToPaidDomainEventHandler.cs
@@ -51,7 +51,7 @@ public async Task Handle(OrderStatusChangedToPaidDomainEvent orderStatusChangedT
                 buyer.Name,
                 orderStockList);
 
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedToPaidIntegrationEvent);         
+            await _orderingIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedToPaidIntegrationEvent);         
         }
     }  
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderShipped/OrderShippedDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderShipped/OrderShippedDomainEventHandler.cs
@@ -41,7 +41,7 @@ public async Task Handle(OrderShippedDomainEvent orderShippedDomainEvent, Cancel
             var buyer = await _buyerRepository.FindByIdAsync(order.GetBuyerId.Value.ToString());
 
             var orderStatusChangedToShippedIntegrationEvent = new OrderStatusChangedToShippedIntegrationEvent(order.Id, order.OrderStatus.Name, buyer.Name);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedToShippedIntegrationEvent);
+            await _orderingIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedToShippedIntegrationEvent);
         }
     }
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderStartedEvent/ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderStartedEvent/ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler.cs
@@ -59,7 +59,7 @@ await _buyerRepository.UnitOfWork
                 .SaveEntitiesAsync();
 
             var orderStatusChangedTosubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(orderStartedEvent.Order.Id, orderStartedEvent.Order.OrderStatus.Name, buyer.Name);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedTosubmittedIntegrationEvent);
+            await _orderingIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedTosubmittedIntegrationEvent);
 
             _logger.CreateLogger(nameof(ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler)).LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: {orderStartedEvent.Order.Id}.");
         }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderStockConfirmed/OrderStatusChangedToStockConfirmedDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderStockConfirmed/OrderStatusChangedToStockConfirmedDomainEventHandler.cs
@@ -41,7 +41,7 @@ public async Task Handle(OrderStatusChangedToStockConfirmedDomainEvent orderStat
             var buyer = await _buyerRepository.FindByIdAsync(order.GetBuyerId.Value.ToString());
 
             var orderStatusChangedToStockConfirmedIntegrationEvent = new OrderStatusChangedToStockConfirmedIntegrationEvent(order.Id, order.OrderStatus.Name, buyer.Name);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedToStockConfirmedIntegrationEvent);            
+            await _orderingIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedToStockConfirmedIntegrationEvent);            
         }
     }  
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/UserCheckoutAcceptedIntegrationEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/UserCheckoutAcceptedIntegrationEventHandler.cs
@@ -11,15 +11,13 @@ namespace Ordering.API.Application.IntegrationEvents.EventHandling
     public class UserCheckoutAcceptedIntegrationEventHandler : IIntegrationEventHandler<UserCheckoutAcceptedIntegrationEvent>
     {
         private readonly IMediator _mediator;
-        private readonly ILoggerFactory _logger;
-        private readonly IOrderingIntegrationEventService _orderingIntegrationEventService;
+        private readonly ILoggerFactory _logger;        
 
         public UserCheckoutAcceptedIntegrationEventHandler(IMediator mediator,
-            ILoggerFactory logger, IOrderingIntegrationEventService orderingIntegrationEventService)
+            ILoggerFactory logger)
         {
             _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator));
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _orderingIntegrationEventService = orderingIntegrationEventService ?? throw new ArgumentNullException(nameof(orderingIntegrationEventService));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));          
         }
 
         /// <summary>
@@ -34,11 +32,7 @@ public UserCheckoutAcceptedIntegrationEventHandler(IMediator mediator,
         public async Task Handle(UserCheckoutAcceptedIntegrationEvent eventMsg)
         {
             var result = false;
-
-            // Send Integration event to clean basket once basket is converted to Order and before starting with the order creation process
-            var orderStartedIntegrationEvent = new OrderStartedIntegrationEvent(eventMsg.UserId);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStartedIntegrationEvent);
-
+           
             if (eventMsg.RequestId != Guid.Empty)
             {
                 var createOrderCommand = new CreateOrderCommand(eventMsg.Basket.Items, eventMsg.UserId, eventMsg.UserName, eventMsg.City, eventMsg.Street, 
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/IOrderingIntegrationEventService.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/IOrderingIntegrationEventService.cs
@@ -5,6 +5,7 @@ namespace Ordering.API.Application.IntegrationEvents
 {
     public interface IOrderingIntegrationEventService
     {
-        Task PublishThroughEventBusAsync(IntegrationEvent evt);
+        Task PublishEventsThroughEventBusAsync();
+        Task AddAndSaveEventAsync(IntegrationEvent evt);
     }
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/OrderingIntegrationEventService.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/OrderingIntegrationEventService.cs
diff --git a/src/Services/Ordering/Ordering.API/Startup.cs b/src/Services/Ordering/Ordering.API/Startup.cs

Original file line number	Diff line number	Diff line change
`@@ -217,14 +217,16 @@ private async Task ProcessEvent(string eventName, string message)`
`217`	`217`	`if (subscription.IsDynamic)`
`218`	`218`	`{`
`219`	`219`	`var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;`
	`220`	`+ if (handler == null) continue;`
`220`	`221`	`dynamic eventData = JObject.Parse(message);`
`221`	`222`	`await handler.Handle(eventData);`
`222`	`223`	`}`
`223`	`224`	`else`
`224`	`225`	`{`
	`226`	`+ var handler = scope.ResolveOptional(subscription.HandlerType);`
	`227`	`+ if (handler == null) continue;`
`225`	`228`	`var eventType = _subsManager.GetEventTypeByName(eventName);`
`226`	`229`	`var integrationEvent = JsonConvert.DeserializeObject(message, eventType);`
`227`		`- var handler = scope.ResolveOptional(subscription.HandlerType);`
`228`	`230`	`var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType);`
`229`	`231`	`await (Task)concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });`
`230`	`232`	`}`
Original file line number	Diff line number	Diff line change
`@@ -163,14 +163,16 @@ private async Task<bool> ProcessEvent(string eventName, string message)`
`163`	`163`	`if (subscription.IsDynamic)`
`164`	`164`	`{`
`165`	`165`	`var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;`
	`166`	`+ if (handler == null) continue;`
`166`	`167`	`dynamic eventData = JObject.Parse(message);`
`167`	`168`	`await handler.Handle(eventData);`
`168`	`169`	`}`
`169`	`170`	`else`
`170`	`171`	`{`
`171`		`- var eventType = _subsManager.GetEventTypeByName(eventName);`
`172`		`- var integrationEvent = JsonConvert.DeserializeObject(message, eventType);`
`173`	`172`	`var handler = scope.ResolveOptional(subscription.HandlerType);`
	`173`	`+ if (handler == null) continue;`
	`174`	`+ var eventType = _subsManager.GetEventTypeByName(eventName);`
	`175`	`+ var integrationEvent = JsonConvert.DeserializeObject(message, eventType);`
`174`	`176`	`var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType);`
`175`	`177`	`await (Task)concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });`
`176`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,8 @@ namespace Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF`
`7`	`7`	`public enum EventStateEnum`
`8`	`8`	`{`
`9`	`9`	`NotPublished = 0,`
`10`		`- Published = 1,`
`11`		`- PublishedFailed = 2`
	`10`	`+ InProgress = 1,`
	`11`	`+ Published = 2,`
	`12`	`+ PublishedFailed = 3`
`12`	`13`	`}`
`13`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,10 @@ namespace Microsoft.eShopOnContainers.BuildingBlocks.IntegrationEventLogEF.Servi`
`9`	`9`	`{`
`10`	`10`	`public interface IIntegrationEventLogService`
`11`	`11`	`{`
	`12`	`+ Task<IEnumerable<IntegrationEventLogEntry>> RetrieveEventLogsPendingToPublishAsync();`
`12`	`13`	`Task SaveEventAsync(IntegrationEvent @event, DbTransaction transaction);`
`13`		`- Task MarkEventAsPublishedAsync(IntegrationEvent @event);`
	`14`	`+ Task MarkEventAsPublishedAsync(Guid eventId);`
	`15`	`+ Task MarkEventAsInProgressAsync(Guid eventId);`
	`16`	`+ Task MarkEventAsFailedAsync(Guid eventId);`
`14`	`17`	`}`
`15`	`18`	`}`