naming changes

christian147 · christian147 · commit 0ee173cd34e0 · 2017-05-17T11:57:02.000+02:00
diff --git a/src/Services/Catalog/Catalog.API/IntegrationCommands/CommandHandlers/ConfirmOrderStockCommandHandler.cs b/src/Services/Catalog/Catalog.API/IntegrationCommands/CommandHandlers/ConfirmOrderStockCommandHandler.cs
@@ -12,23 +12,23 @@
     using Commands;
     using IntegrationEvents.Events;
 
-    public class ConfirmOrderStockCommandMsgHandler : IIntegrationEventHandler<ConfirmOrderStockCommandMsg>
+    public class ConfirmOrderStockCommandHandler : IIntegrationEventHandler<ConfirmOrderStockCommand>
     {
         private readonly CatalogContext _catalogContext;
         private readonly ICatalogIntegrationEventService _catalogIntegrationEventService;
 
-        public ConfirmOrderStockCommandMsgHandler(CatalogContext catalogContext,
+        public ConfirmOrderStockCommandHandler(CatalogContext catalogContext,
             ICatalogIntegrationEventService catalogIntegrationEventService)
         {
             _catalogContext = catalogContext;
             _catalogIntegrationEventService = catalogIntegrationEventService;
         }
 
-        public async Task Handle(ConfirmOrderStockCommandMsg @event)
+        public async Task Handle(ConfirmOrderStockCommand command)
         {
             var confirmedOrderStockItems = new List<ConfirmedOrderStockItem>();
 
-            foreach (var orderStockItem in @event.OrderStockItems)
+            foreach (var orderStockItem in command.OrderStockItems)
             {
                 var catalogItem = _catalogContext.CatalogItems.Find(orderStockItem.ProductId);
                 CheckValidcatalogItemId(catalogItem);
@@ -39,9 +39,9 @@ public async Task Handle(ConfirmOrderStockCommandMsg @event)
                 confirmedOrderStockItems.Add(confirmedOrderStockItem);
             }
 
-            var confirmedIntegrationEvent = confirmedOrderStockItems.Any(c => !c.Confirmed)
-                ? (IntegrationEvent) new OrderStockNotConfirmedIntegrationEvent(@event.OrderId, confirmedOrderStockItems)
-                : new OrderStockConfirmedIntegrationEvent(@event.OrderId);
+            var confirmedIntegrationEvent = confirmedOrderStockItems.Any(c => !c.HasStock)
+                ? (IntegrationEvent) new OrderStockNotConfirmedIntegrationEvent(command.OrderId, confirmedOrderStockItems)
+                : new OrderStockConfirmedIntegrationEvent(command.OrderId);
 
             await _catalogIntegrationEventService.SaveEventAndCatalogContextChangesAsync(confirmedIntegrationEvent);
             await _catalogIntegrationEventService.PublishThroughEventBusAsync(confirmedIntegrationEvent);
diff --git a/src/Services/Catalog/Catalog.API/IntegrationCommands/CommandHandlers/DecrementOrderStockCommandHandler.cs b/src/Services/Catalog/Catalog.API/IntegrationCommands/CommandHandlers/DecrementOrderStockCommandHandler.cs
@@ -5,19 +5,19 @@
     using Infrastructure;
     using Commands;
 
-    public class DecrementOrderStockCommandMsgHandler : IIntegrationEventHandler<DecrementOrderStockCommandMsg>
+    public class DecrementOrderStockCommandHandler : IIntegrationEventHandler<DecrementOrderStockCommand>
     {
         private readonly CatalogContext _catalogContext;
 
-        public DecrementOrderStockCommandMsgHandler(CatalogContext catalogContext)
+        public DecrementOrderStockCommandHandler(CatalogContext catalogContext)
         {
             _catalogContext = catalogContext;
         }
 
-        public async Task Handle(DecrementOrderStockCommandMsg @event)
+        public async Task Handle(DecrementOrderStockCommand command)
         {
             //we're not blocking stock/inventory
-            foreach (var orderStockItem in @event.OrderStockItems)
+            foreach (var orderStockItem in command.OrderStockItems)
             {
                 var catalogItem = _catalogContext.CatalogItems.Find(orderStockItem.ProductId);
 
diff --git a/src/Services/Catalog/Catalog.API/IntegrationCommands/Commands/ConfirmOrderStockCommand.cs b/src/Services/Catalog/Catalog.API/IntegrationCommands/Commands/ConfirmOrderStockCommand.cs
@@ -3,12 +3,12 @@
     using BuildingBlocks.EventBus.Events;
     using System.Collections.Generic;
 
-    public class ConfirmOrderStockCommandMsg : IntegrationEvent
+    public class ConfirmOrderStockCommand : IntegrationEvent
     {
         public int OrderId { get; }
         public IEnumerable<OrderStockItem> OrderStockItems { get; }
 
-        public ConfirmOrderStockCommandMsg(int orderId,
+        public ConfirmOrderStockCommand(int orderId,
             IEnumerable<OrderStockItem> orderStockItems)
         {
             OrderId = orderId;
diff --git a/src/Services/Catalog/Catalog.API/IntegrationCommands/Commands/DecrementOrderStockCommand.cs b/src/Services/Catalog/Catalog.API/IntegrationCommands/Commands/DecrementOrderStockCommand.cs
@@ -3,12 +3,12 @@
     using System.Collections.Generic;
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 
-    public class DecrementOrderStockCommandMsg : IntegrationEvent
+    public class DecrementOrderStockCommand : IntegrationEvent
     {
         public int OrderId { get; }
         public IEnumerable<OrderStockItem> OrderStockItems { get; }
 
-        public DecrementOrderStockCommandMsg(int orderId,
+        public DecrementOrderStockCommand(int orderId,
             IEnumerable<OrderStockItem> orderStockItems)
         {
             OrderId = orderId;
diff --git a/src/Services/Catalog/Catalog.API/IntegrationEvents/Events/OrderStockNotConfirmedIntegrationEvent.cs b/src/Services/Catalog/Catalog.API/IntegrationEvents/Events/OrderStockNotConfirmedIntegrationEvent.cs
@@ -20,12 +20,12 @@ public OrderStockNotConfirmedIntegrationEvent(int orderId,
     public class ConfirmedOrderStockItem
     {
         public int ProductId { get; }
-        public bool Confirmed { get; }
+        public bool HasStock { get; }
 
-        public ConfirmedOrderStockItem(int productId, bool confirmed)
+        public ConfirmedOrderStockItem(int productId, bool hasStock)
         {
             ProductId = productId;
-            Confirmed = confirmed;
+            HasStock = hasStock;
         }
     }
 }
diff --git a/src/Services/Catalog/Catalog.API/Startup.cs b/src/Services/Catalog/Catalog.API/Startup.cs
@@ -190,19 +190,19 @@ private void RegisterServiceBus(IServiceCollection services)
             services.AddSingleton<IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
             services.AddSingleton<IEventBus, EventBusRabbitMQ>();
 
-            services.AddTransient<IIntegrationEventHandler<ConfirmOrderStockCommandMsg>,
-                ConfirmOrderStockCommandMsgHandler>();
-            services.AddTransient<IIntegrationEventHandler<DecrementOrderStockCommandMsg>,
-                DecrementOrderStockCommandMsgHandler>();
+            services.AddTransient<IIntegrationEventHandler<ConfirmOrderStockCommand>,
+                ConfirmOrderStockCommandHandler>();
+            services.AddTransient<IIntegrationEventHandler<DecrementOrderStockCommand>,
+                DecrementOrderStockCommandHandler>();
 
         }
 
         private void ConfigureEventBus(IApplicationBuilder app)
         {
             var eventBus = app.ApplicationServices.GetRequiredService<IEventBus>();
 
-            eventBus.Subscribe<ConfirmOrderStockCommandMsg, IIntegrationEventHandler<ConfirmOrderStockCommandMsg>>();
-            eventBus.Subscribe<DecrementOrderStockCommandMsg, IIntegrationEventHandler<DecrementOrderStockCommandMsg>>();
+            eventBus.Subscribe<ConfirmOrderStockCommand, IIntegrationEventHandler<ConfirmOrderStockCommand>>();
+            eventBus.Subscribe<DecrementOrderStockCommand, IIntegrationEventHandler<DecrementOrderStockCommand>>();
         }
     }
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderGracePeriodConfirmed/OrderStatusChangedToAwaitingValidationDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderGracePeriodConfirmed/OrderStatusChangedToAwaitingValidationDomainEventHandler.cs
@@ -35,10 +35,10 @@ public async Task Handle(OrderStatusChangedToAwaitingValidationDomainEvent order
             var orderStockList = orderStatusChangedToAwaitingValidationDomainEvent.OrderItems
                 .Select(orderItem => new OrderStockItem(orderItem.ProductId, orderItem.GetUnits()));
 
-            var confirmOrderStockEvent = new ConfirmOrderStockCommandMsg(orderStatusChangedToAwaitingValidationDomainEvent.OrderId, 
+            var confirmOrderStockCommand = new ConfirmOrderStockCommand(orderStatusChangedToAwaitingValidationDomainEvent.OrderId, 
                 orderStockList);
-            await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(confirmOrderStockEvent);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(confirmOrderStockEvent);
+            await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(confirmOrderStockCommand);
+            await _orderingIntegrationEventService.PublishThroughEventBusAsync(confirmOrderStockCommand);
         }
     }  
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderPaid/OrderStatusChangedToPaidDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderPaid/OrderStatusChangedToPaidDomainEventHandler.cs
@@ -35,10 +35,10 @@ public async Task Handle(OrderStatusChangedToPaidDomainEvent orderStatusChangedT
             var orderStockList = orderStatusChangedToPaidDomainEvent.OrderItems
                 .Select(orderItem => new OrderStockItem(orderItem.ProductId, orderItem.GetUnits()));
 
-            var decrementOrderStockCommandMsg = new DecrementOrderStockCommandMsg(orderStatusChangedToPaidDomainEvent.OrderId,
+            var decrementOrderStockCommand = new DecrementOrderStockCommand(orderStatusChangedToPaidDomainEvent.OrderId,
                 orderStockList);
-            await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(decrementOrderStockCommandMsg);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(decrementOrderStockCommandMsg);
+            await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(decrementOrderStockCommand);
+            await _orderingIntegrationEventService.PublishThroughEventBusAsync(decrementOrderStockCommand);
         }
     }  
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderStockConfirmed/OrderStatusChangedToStockConfirmedDomainEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/DomainEventHandlers/OrderStockConfirmed/OrderStatusChangedToStockConfirmedDomainEventHandler.cs
@@ -31,9 +31,9 @@ public async Task Handle(OrderStatusChangedToStockConfirmedDomainEvent orderStat
                 .LogTrace($"Order with Id: {orderStatusChangedToStockConfirmedDomainEvent.OrderId} has been successfully updated with " +
                           $"a status order id: {OrderStatus.StockConfirmed.Id}");
 
-            var payOrderCommandMsg = new PayOrderCommandMsg(orderStatusChangedToStockConfirmedDomainEvent.OrderId);
-            await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(payOrderCommandMsg);
-            await _orderingIntegrationEventService.PublishThroughEventBusAsync(payOrderCommandMsg);
+            var payOrderCommand = new PayOrderCommand(orderStatusChangedToStockConfirmedDomainEvent.OrderId);
+            await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(payOrderCommand);
+            await _orderingIntegrationEventService.PublishThroughEventBusAsync(payOrderCommand);
         }
     }  
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/ConfirmGracePeriodCommand.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/ConfirmGracePeriodCommand.cs
@@ -2,11 +2,11 @@
 
 namespace Ordering.API.Application.IntegrationCommands.Commands
 {
-    public class ConfirmGracePeriodCommandMsg : IntegrationEvent
+    public class ConfirmGracePeriodCommand : IntegrationEvent
     {
         public int OrderId { get; }
 
-        public ConfirmGracePeriodCommandMsg(int orderId) =>
+        public ConfirmGracePeriodCommand(int orderId) =>
             OrderId = orderId;
     }
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/ConfirmOrderStockCommand.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/ConfirmOrderStockCommand.cs
@@ -3,12 +3,12 @@
     using System.Collections.Generic;
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 
-    public class ConfirmOrderStockCommandMsg : IntegrationEvent
+    public class ConfirmOrderStockCommand : IntegrationEvent
     {
         public int OrderId { get; }
         public IEnumerable<OrderStockItem> OrderStockItems { get; }
 
-        public ConfirmOrderStockCommandMsg(int orderId,
+        public ConfirmOrderStockCommand(int orderId,
             IEnumerable<OrderStockItem> orderStockItems)
         {
             OrderId = orderId;
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/DecrementOrderStockCommand.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/DecrementOrderStockCommand.cs
@@ -3,12 +3,12 @@
     using System.Collections.Generic;
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 
-    public class DecrementOrderStockCommandMsg : IntegrationEvent
+    public class DecrementOrderStockCommand : IntegrationEvent
     {
         public int OrderId { get; }
         public IEnumerable<OrderStockItem> OrderStockItems { get; }
 
-        public DecrementOrderStockCommandMsg(int orderId,
+        public DecrementOrderStockCommand(int orderId,
             IEnumerable<OrderStockItem> orderStockItems)
         {
             OrderId = orderId;
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/PayOrderCommand.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/PayOrderCommand.cs
@@ -2,11 +2,11 @@
 {
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 
-    public class PayOrderCommandMsg : IntegrationEvent
+    public class PayOrderCommand : IntegrationEvent
     {
         public int OrderId { get; }
 
-        public PayOrderCommandMsg(int orderId)
+        public PayOrderCommand(int orderId)
         {
             OrderId = orderId;
         }
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/ShipOrderCommandMsg.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationCommands/Commands/ShipOrderCommandMsg.cs
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/OrderStockNotConfirmedIntegrationEventHandler.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/EventHandling/OrderStockNotConfirmedIntegrationEventHandler.cs
@@ -22,7 +22,7 @@ public async Task Handle(OrderStockNotConfirmedIntegrationEvent @event)
             var orderToUpdate = await _orderRepository.GetWithDependenciesAsync(@event.OrderId);
 
             var orderStockNotConfirmedItems = @event.OrderStockItems
-                .FindAll(c => !c.Confirmed)
+                .FindAll(c => !c.HasStock)
                 .Select(c => c.ProductId);
 
             orderToUpdate.SetStockConfirmedStatus(orderStockNotConfirmedItems);
diff --git a/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/Events/OrderStockNotConfirmedIntegrationEvent.cs b/src/Services/Ordering/Ordering.API/Application/IntegrationEvents/Events/OrderStockNotConfirmedIntegrationEvent.cs
@@ -21,12 +21,12 @@ public OrderStockNotConfirmedIntegrationEvent(int orderId,
     public class ConfirmedOrderStockItem
     {
         public int ProductId { get; }
-        public bool Confirmed { get; }
+        public bool HasStock { get; }
 
-        public ConfirmedOrderStockItem(int productId, bool confirmed)
+        public ConfirmedOrderStockItem(int productId, bool hasStock)
         {
             ProductId = productId;
-            Confirmed = confirmed;
+            HasStock = hasStock;
         }
     }
 }
diff --git a/src/Services/Ordering/Ordering.API/Application/Sagas/OrderProcessSaga.cs b/src/Services/Ordering/Ordering.API/Application/Sagas/OrderProcessSaga.cs
@@ -21,7 +21,7 @@ namespace Ordering.API.Application.Sagas
     /// with the validations.
     /// </summary>
     public class OrderProcessSaga : OrderSaga,
-        IIntegrationEventHandler<ConfirmGracePeriodCommandMsg>,
+        IIntegrationEventHandler<ConfirmGracePeriodCommand>,
         IAsyncRequestHandler<CancelOrderCommand, bool>,
         IAsyncRequestHandler<ShipOrderCommand, bool>
     {
@@ -43,7 +43,7 @@ public OrderProcessSaga(
         /// period has completed.
         /// </param>
         /// <returns></returns>
-        public async Task Handle(ConfirmGracePeriodCommandMsg command)
+        public async Task Handle(ConfirmGracePeriodCommand command)
         {
             var orderSaga = FindSagaById(command.OrderId);
             CheckValidSagaId(orderSaga);
diff --git a/src/Services/Ordering/Ordering.API/Startup.cs b/src/Services/Ordering/Ordering.API/Startup.cs
@@ -171,7 +171,7 @@ private void RegisterServiceBus(IServiceCollection services)
             services.AddSingleton<IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
 
             services.AddTransient<IIntegrationEventHandler<UserCheckoutAcceptedIntegrationEvent>>();
-            services.AddTransient<IIntegrationEventHandler<ConfirmGracePeriodCommandMsg>, OrderProcessSaga>();
+            services.AddTransient<IIntegrationEventHandler<ConfirmGracePeriodCommand>, OrderProcessSaga>();
             services.AddTransient<IIntegrationEventHandler<OrderStockConfirmedIntegrationEvent>,
                 OrderStockConfirmedIntegrationEventHandler>();
             services.AddTransient<IIntegrationEventHandler<OrderStockNotConfirmedIntegrationEvent>,
@@ -187,7 +187,7 @@ private void ConfigureEventBus(IApplicationBuilder app)
             var eventBus = app.ApplicationServices.GetRequiredService<IEventBus>();
 
             eventBus.Subscribe<UserCheckoutAcceptedIntegrationEvent, IIntegrationEventHandler<UserCheckoutAcceptedIntegrationEvent>>();
-            eventBus.Subscribe<ConfirmGracePeriodCommandMsg, IIntegrationEventHandler<ConfirmGracePeriodCommandMsg>>();
+            eventBus.Subscribe<ConfirmGracePeriodCommand, IIntegrationEventHandler<ConfirmGracePeriodCommand>>();
             eventBus.Subscribe<OrderStockConfirmedIntegrationEvent, IIntegrationEventHandler<OrderStockConfirmedIntegrationEvent>>();
             eventBus.Subscribe<OrderStockNotConfirmedIntegrationEvent, IIntegrationEventHandler<OrderStockNotConfirmedIntegrationEvent>>();
             eventBus.Subscribe<OrderPaymentFailedIntegrationEvent, IIntegrationEventHandler<OrderPaymentFailedIntegrationEvent>>();
diff --git a/src/Services/Payment/Payment.API/IntegrationCommands/CommandHandlers/PayOrderCommandHandler.cs b/src/Services/Payment/Payment.API/IntegrationCommands/CommandHandlers/PayOrderCommandHandler.cs
@@ -3,21 +3,17 @@
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Abstractions;
     using Payment.API.IntegrationCommands.Commands;
     using System.Threading.Tasks;
-    using System;
     using Payment.API.IntegrationEvents;
     using Payment.API.IntegrationEvents.Events;
 
-    public class PayOrderCommandMsgHandler : IIntegrationEventHandler<PayOrderCommandMsg>
+    public class PayOrderCommandHandler : IIntegrationEventHandler<PayOrderCommand>
     {
         private readonly IPaymentIntegrationEventService _paymentIntegrationEventService;
 
-        public PayOrderCommandMsgHandler(IPaymentIntegrationEventService paymentIntegrationEventService)
-        {
-            _paymentIntegrationEventService = paymentIntegrationEventService;
-        }
-
+        public PayOrderCommandHandler(IPaymentIntegrationEventService paymentIntegrationEventService)
+            => _paymentIntegrationEventService = paymentIntegrationEventService;
 
-        public async Task Handle(PayOrderCommandMsg @event)
+        public async Task Handle(PayOrderCommand @event)
         {
             //PAYMENT SUCCESSED
             var orderPaymentSuccededIntegrationEvent = new OrderPaymentSuccededIntegrationEvent(@event.OrderId);
@@ -28,4 +24,4 @@ public async Task Handle(PayOrderCommandMsg @event)
             //_paymentIntegrationEventService.PublishThroughEventBus(orderPaymentFailedIntegrationEvent);
         }
     }
-}
+}
diff --git a/src/Services/Payment/Payment.API/IntegrationCommands/Commands/PayOrderCommand.cs b/src/Services/Payment/Payment.API/IntegrationCommands/Commands/PayOrderCommand.cs
@@ -2,10 +2,10 @@
 {
     using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;
 
-    public class PayOrderCommandMsg : IntegrationEvent
+    public class PayOrderCommand : IntegrationEvent
     {
         public int OrderId { get; }
 
-        public PayOrderCommandMsg(int orderId) => OrderId = orderId;
+        public PayOrderCommand(int orderId) => OrderId = orderId;
     }
 }
diff --git a/src/Services/Payment/Payment.API/Startup.cs b/src/Services/Payment/Payment.API/Startup.cs
@@ -48,10 +48,8 @@ public IServiceProvider ConfigureServices(IServiceCollection services)
 
                 return new DefaultRabbitMQPersistentConnection(factory, logger);
             });
-            services.AddSingleton<IEventBus, EventBusRabbitMQ>();
-            services.AddSingleton<IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
-            services.AddTransient<IIntegrationEventHandler<PayOrderCommandMsg>, PayOrderCommandMsgHandler>();
-            
+
+            RegisterServiceBus(services);
 
             services.AddSwaggerGen();
             services.ConfigureSwaggerGen(options =>
@@ -85,10 +83,18 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerF
             ConfigureEventBus(app);
         }
 
+        private void RegisterServiceBus(IServiceCollection services)
+        {
+            services.AddSingleton<IEventBus, EventBusRabbitMQ>();
+            services.AddSingleton<IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
+
+            services.AddTransient<IIntegrationEventHandler<PayOrderCommand>, PayOrderCommandHandler>();
+        }
+
         private void ConfigureEventBus(IApplicationBuilder app)
         {
             var eventBus = app.ApplicationServices.GetRequiredService<IEventBus>();
-            eventBus.Subscribe<PayOrderCommandMsg, IIntegrationEventHandler<PayOrderCommandMsg>>();
+            eventBus.Subscribe<PayOrderCommand, IIntegrationEventHandler<PayOrderCommand>>();
         }
     }
 }
diff --git a/src/Services/SagaManager/SagaManager/IntegrationEvents/Events/ConfirmGracePeriodCommand.cs b/src/Services/SagaManager/SagaManager/IntegrationEvents/Events/ConfirmGracePeriodCommand.cs
diff --git a/src/Services/SagaManager/SagaManager/Program.cs b/src/Services/SagaManager/SagaManager/Program.cs
diff --git a/src/Services/SagaManager/SagaManager/Services/ISagaManagerService.cs b/src/Services/SagaManager/SagaManager/Services/ISagaManagerService.cs
diff --git a/src/Services/SagaManager/SagaManager/Services/SagaManagerService.cs b/src/Services/SagaManager/SagaManager/Services/SagaManagerService.cs

Original file line number	Diff line number	Diff line change
`@@ -12,23 +12,23 @@`
`12`	`12`	`using Commands;`
`13`	`13`	`using IntegrationEvents.Events;`
`14`	`14`
`15`		`- public class ConfirmOrderStockCommandMsgHandler : IIntegrationEventHandler<ConfirmOrderStockCommandMsg>`
	`15`	`+ public class ConfirmOrderStockCommandHandler : IIntegrationEventHandler<ConfirmOrderStockCommand>`
`16`	`16`	`{`
`17`	`17`	`private readonly CatalogContext _catalogContext;`
`18`	`18`	`private readonly ICatalogIntegrationEventService _catalogIntegrationEventService;`
`19`	`19`
`20`		`- public ConfirmOrderStockCommandMsgHandler(CatalogContext catalogContext,`
	`20`	`+ public ConfirmOrderStockCommandHandler(CatalogContext catalogContext,`
`21`	`21`	`ICatalogIntegrationEventService catalogIntegrationEventService)`
`22`	`22`	`{`
`23`	`23`	`_catalogContext = catalogContext;`
`24`	`24`	`_catalogIntegrationEventService = catalogIntegrationEventService;`
`25`	`25`	`}`
`26`	`26`
`27`		`- public async Task Handle(ConfirmOrderStockCommandMsg @event)`
	`27`	`+ public async Task Handle(ConfirmOrderStockCommand command)`
`28`	`28`	`{`
`29`	`29`	`var confirmedOrderStockItems = new List<ConfirmedOrderStockItem>();`
`30`	`30`
`31`		`- foreach (var orderStockItem in @event.OrderStockItems)`
	`31`	`+ foreach (var orderStockItem in command.OrderStockItems)`
`32`	`32`	`{`
`33`	`33`	`var catalogItem = _catalogContext.CatalogItems.Find(orderStockItem.ProductId);`
`34`	`34`	`CheckValidcatalogItemId(catalogItem);`
`@@ -39,9 +39,9 @@ public async Task Handle(ConfirmOrderStockCommandMsg @event)`
`39`	`39`	`confirmedOrderStockItems.Add(confirmedOrderStockItem);`
`40`	`40`	`}`
`41`	`41`
`42`		`- var confirmedIntegrationEvent = confirmedOrderStockItems.Any(c => !c.Confirmed)`
`43`		`- ? (IntegrationEvent) new OrderStockNotConfirmedIntegrationEvent(@event.OrderId, confirmedOrderStockItems)`
`44`		`- : new OrderStockConfirmedIntegrationEvent(@event.OrderId);`
	`42`	`+ var confirmedIntegrationEvent = confirmedOrderStockItems.Any(c => !c.HasStock)`
	`43`	`+ ? (IntegrationEvent) new OrderStockNotConfirmedIntegrationEvent(command.OrderId, confirmedOrderStockItems)`
	`44`	`+ : new OrderStockConfirmedIntegrationEvent(command.OrderId);`
`45`	`45`
`46`	`46`	`await _catalogIntegrationEventService.SaveEventAndCatalogContextChangesAsync(confirmedIntegrationEvent);`
`47`	`47`	`await _catalogIntegrationEventService.PublishThroughEventBusAsync(confirmedIntegrationEvent);`
Original file line number	Diff line number	Diff line change
`@@ -5,19 +5,19 @@`
`5`	`5`	`using Infrastructure;`
`6`	`6`	`using Commands;`
`7`	`7`
`8`		`- public class DecrementOrderStockCommandMsgHandler : IIntegrationEventHandler<DecrementOrderStockCommandMsg>`
	`8`	`+ public class DecrementOrderStockCommandHandler : IIntegrationEventHandler<DecrementOrderStockCommand>`
`9`	`9`	`{`
`10`	`10`	`private readonly CatalogContext _catalogContext;`
`11`	`11`
`12`		`- public DecrementOrderStockCommandMsgHandler(CatalogContext catalogContext)`
	`12`	`+ public DecrementOrderStockCommandHandler(CatalogContext catalogContext)`
`13`	`13`	`{`
`14`	`14`	`_catalogContext = catalogContext;`
`15`	`15`	`}`
`16`	`16`
`17`		`- public async Task Handle(DecrementOrderStockCommandMsg @event)`
	`17`	`+ public async Task Handle(DecrementOrderStockCommand command)`
`18`	`18`	`{`
`19`	`19`	`//we're not blocking stock/inventory`
`20`		`- foreach (var orderStockItem in @event.OrderStockItems)`
	`20`	`+ foreach (var orderStockItem in command.OrderStockItems)`
`21`	`21`	`{`
`22`	`22`	`var catalogItem = _catalogContext.CatalogItems.Find(orderStockItem.ProductId);`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -3,12 +3,12 @@`
`3`	`3`	`using BuildingBlocks.EventBus.Events;`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`
`6`		`- public class ConfirmOrderStockCommandMsg : IntegrationEvent`
	`6`	`+ public class ConfirmOrderStockCommand : IntegrationEvent`
`7`	`7`	`{`
`8`	`8`	`public int OrderId { get; }`
`9`	`9`	`public IEnumerable<OrderStockItem> OrderStockItems { get; }`
`10`	`10`
`11`		`- public ConfirmOrderStockCommandMsg(int orderId,`
	`11`	`+ public ConfirmOrderStockCommand(int orderId,`
`12`	`12`	`IEnumerable<OrderStockItem> orderStockItems)`
`13`	`13`	`{`
`14`	`14`	`OrderId = orderId;`
Original file line number	Diff line number	Diff line change
`@@ -3,12 +3,12 @@`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events;`
`5`	`5`
`6`		`- public class DecrementOrderStockCommandMsg : IntegrationEvent`
	`6`	`+ public class DecrementOrderStockCommand : IntegrationEvent`
`7`	`7`	`{`
`8`	`8`	`public int OrderId { get; }`
`9`	`9`	`public IEnumerable<OrderStockItem> OrderStockItems { get; }`
`10`	`10`
`11`		`- public DecrementOrderStockCommandMsg(int orderId,`
	`11`	`+ public DecrementOrderStockCommand(int orderId,`
`12`	`12`	`IEnumerable<OrderStockItem> orderStockItems)`
`13`	`13`	`{`
`14`	`14`	`OrderId = orderId;`
Original file line number	Diff line number	Diff line change
`@@ -20,12 +20,12 @@ public OrderStockNotConfirmedIntegrationEvent(int orderId,`
`20`	`20`	`public class ConfirmedOrderStockItem`
`21`	`21`	`{`
`22`	`22`	`public int ProductId { get; }`
`23`		`- public bool Confirmed { get; }`
	`23`	`+ public bool HasStock { get; }`
`24`	`24`
`25`		`- public ConfirmedOrderStockItem(int productId, bool confirmed)`
	`25`	`+ public ConfirmedOrderStockItem(int productId, bool hasStock)`
`26`	`26`	`{`
`27`	`27`	`ProductId = productId;`
`28`		`- Confirmed = confirmed;`
	`28`	`+ HasStock = hasStock;`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -190,19 +190,19 @@ private void RegisterServiceBus(IServiceCollection services)`
`190`	`190`	`services.AddSingleton<IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();`
`191`	`191`	`services.AddSingleton<IEventBus, EventBusRabbitMQ>();`
`192`	`192`
`193`		`- services.AddTransient<IIntegrationEventHandler<ConfirmOrderStockCommandMsg>,`
`194`		`- ConfirmOrderStockCommandMsgHandler>();`
`195`		`- services.AddTransient<IIntegrationEventHandler<DecrementOrderStockCommandMsg>,`
`196`		`- DecrementOrderStockCommandMsgHandler>();`
	`193`	`+ services.AddTransient<IIntegrationEventHandler<ConfirmOrderStockCommand>,`
	`194`	`+ ConfirmOrderStockCommandHandler>();`
	`195`	`+ services.AddTransient<IIntegrationEventHandler<DecrementOrderStockCommand>,`
	`196`	`+ DecrementOrderStockCommandHandler>();`
`197`	`197`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`private void ConfigureEventBus(IApplicationBuilder app)`
`201`	`201`	`{`
`202`	`202`	`var eventBus = app.ApplicationServices.GetRequiredService<IEventBus>();`
`203`	`203`
`204`		`- eventBus.Subscribe<ConfirmOrderStockCommandMsg, IIntegrationEventHandler<ConfirmOrderStockCommandMsg>>();`
`205`		`- eventBus.Subscribe<DecrementOrderStockCommandMsg, IIntegrationEventHandler<DecrementOrderStockCommandMsg>>();`
	`204`	`+ eventBus.Subscribe<ConfirmOrderStockCommand, IIntegrationEventHandler<ConfirmOrderStockCommand>>();`
	`205`	`+ eventBus.Subscribe<DecrementOrderStockCommand, IIntegrationEventHandler<DecrementOrderStockCommand>>();`
`206`	`206`	`}`
`207`	`207`	`}`
`208`	`208`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,10 +35,10 @@ public async Task Handle(OrderStatusChangedToAwaitingValidationDomainEvent order`
`35`	`35`	`var orderStockList = orderStatusChangedToAwaitingValidationDomainEvent.OrderItems`
`36`	`36`	`.Select(orderItem => new OrderStockItem(orderItem.ProductId, orderItem.GetUnits()));`
`37`	`37`
`38`		`- var confirmOrderStockEvent = new ConfirmOrderStockCommandMsg(orderStatusChangedToAwaitingValidationDomainEvent.OrderId,`
	`38`	`+ var confirmOrderStockCommand = new ConfirmOrderStockCommand(orderStatusChangedToAwaitingValidationDomainEvent.OrderId,`
`39`	`39`	`orderStockList);`
`40`		`- await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(confirmOrderStockEvent);`
`41`		`- await _orderingIntegrationEventService.PublishThroughEventBusAsync(confirmOrderStockEvent);`
	`40`	`+ await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(confirmOrderStockCommand);`
	`41`	`+ await _orderingIntegrationEventService.PublishThroughEventBusAsync(confirmOrderStockCommand);`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,9 +31,9 @@ public async Task Handle(OrderStatusChangedToStockConfirmedDomainEvent orderStat`
`31`	`31`	`.LogTrace($"Order with Id: {orderStatusChangedToStockConfirmedDomainEvent.OrderId} has been successfully updated with " +`
`32`	`32`	`$"a status order id: {OrderStatus.StockConfirmed.Id}");`
`33`	`33`
`34`		`- var payOrderCommandMsg = new PayOrderCommandMsg(orderStatusChangedToStockConfirmedDomainEvent.OrderId);`
`35`		`- await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(payOrderCommandMsg);`
`36`		`- await _orderingIntegrationEventService.PublishThroughEventBusAsync(payOrderCommandMsg);`
	`34`	`+ var payOrderCommand = new PayOrderCommand(orderStatusChangedToStockConfirmedDomainEvent.OrderId);`
	`35`	`+ await _orderingIntegrationEventService.SaveEventAndOrderingContextChangesAsync(payOrderCommand);`
	`36`	`+ await _orderingIntegrationEventService.PublishThroughEventBusAsync(payOrderCommand);`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,11 @@`
`2`	`2`
`3`	`3`	`namespace Ordering.API.Application.IntegrationCommands.Commands`
`4`	`4`	`{`
`5`		`- public class ConfirmGracePeriodCommandMsg : IntegrationEvent`
	`5`	`+ public class ConfirmGracePeriodCommand : IntegrationEvent`
`6`	`6`	`{`
`7`	`7`	`public int OrderId { get; }`
`8`	`8`
`9`		`- public ConfirmGracePeriodCommandMsg(int orderId) =>`
	`9`	`+ public ConfirmGracePeriodCommand(int orderId) =>`
`10`	`10`	`OrderId = orderId;`
`11`	`11`	`}`
`12`	`12`	`}`