Refactor repositories.

Anthony Sneed · Anthony Sneed · commit 58378cd01154 · 2022-02-21T16:26:08.000-06:00
diff --git a/reference-architecture/CustomerService/Controllers/CustomerQueryController.cs b/reference-architecture/CustomerService/Controllers/CustomerQueryController.cs
@@ -25,7 +25,7 @@ public CustomerQueryController(ICustomerRepository repository, IMapper mapper)
         [HttpGet]
         public async Task<IActionResult> GetCustomers()
         {
-            var customers = await _repository.Get();
+            var customers = await _repository.GetAsync();
             var result = _mapper.Map<IEnumerable<CustomerView>>(customers);
             return Ok(result);
         }
@@ -35,7 +35,7 @@ public async Task<IActionResult> GetCustomers()
         [Route("{id}")]
         public async Task<IActionResult> GetCustomer([FromRoute] Guid id)
         {
-            var customer = await _repository.Get(id);
+            var customer = await _repository.GetAsync(id);
             if (customer == null) return NotFound();
             var result = _mapper.Map<CustomerView>(customer);
             return Ok(result);
diff --git a/reference-architecture/CustomerService/Domain/CustomerAggregate/CommandHandlers/CustomerCommandHandler.cs b/reference-architecture/CustomerService/Domain/CustomerAggregate/CommandHandlers/CustomerCommandHandler.cs
@@ -42,7 +42,7 @@ public async Task<CommandResult<Customer>> Handle(CreateCustomer command)
             command.Entity.Apply(domainEvent);
             
             // Persist entity
-            var entity = await _repository.Add(command.Entity);
+            var entity = await _repository.AddAsync(command.Entity);
             if (entity == null) return new CommandResult<Customer>(CommandOutcome.InvalidCommand);
             return new CommandResult<Customer>(CommandOutcome.Accepted, entity);
         }
@@ -51,14 +51,14 @@ public async Task<CommandResult<Customer>> Handle(UpdateCustomer command)
         {
             // Compare shipping addresses
             _logger.LogInformation("Handling command: {CommandName}", nameof(UpdateCustomer));
-            var existing = await _repository.Get(command.EntityId);
+            var existing = await _repository.GetAsync(command.EntityId);
             if (existing == null) return new CommandResult<Customer>(CommandOutcome.NotHandled);
             var addressChanged = command.Entity.ShippingAddress != existing.ShippingAddress;
             
             try
             {
                 // Persist entity
-                var entity = await _repository.Update(command.Entity);
+                var entity = await _repository.UpdateAsync(command.Entity);
                 if (entity == null) return new CommandResult<Customer>(CommandOutcome.NotFound);
                 
                 // Publish events
@@ -82,7 +82,7 @@ public async Task<CommandResult<Customer>> Handle(RemoveCustomer command)
         {
             // Persist entity
             _logger.LogInformation("Handling command: {CommandName}", nameof(RemoveCustomer));
-            await _repository.Remove(command.EntityId);
+            await _repository.RemoveAsync(command.EntityId);
             return new CommandResult<Customer>(CommandOutcome.Accepted);
         }
     }
diff --git a/reference-architecture/CustomerService/Repositories/CustomerRepository.cs b/reference-architecture/CustomerService/Repositories/CustomerRepository.cs
@@ -3,50 +3,45 @@
 using System.Threading.Tasks;
 using CustomerService.Domain.CustomerAggregate;
 using Microsoft.Extensions.Logging;
+using MongoDB.Driver;
 using URF.Core.Abstractions;
+using URF.Core.Mongo;
 
 namespace CustomerService.Repositories
 {
-    public class CustomerRepository : ICustomerRepository
+    public class CustomerRepository : DocumentRepository<Customer>, ICustomerRepository
     {
-        private readonly ILogger<CustomerRepository> _logger;
-        private readonly IDocumentRepository<Customer> _documentRepository;
-
-        public CustomerRepository(
-            IDocumentRepository<Customer> documentRepository,
-            ILogger<CustomerRepository> logger)
+        public CustomerRepository(IMongoCollection<Customer> collection) : base(collection)
         {
-            _documentRepository = documentRepository;
-            _logger = logger;
         }
 
-        public async Task<IEnumerable<Customer>> Get() =>
-            await _documentRepository.FindManyAsync();
+        public async Task<IEnumerable<Customer>> GetAsync() =>
+            await FindManyAsync();
 
-        public async Task<Customer> Get(Guid id) =>
-            await _documentRepository.FindOneAsync(e => e.Id == id);
+        public async Task<Customer> GetAsync(Guid id) =>
+            await FindOneAsync(e => e.Id == id);
 
-        public async Task<Customer> Add(Customer entity)
+        public async Task<Customer> AddAsync(Customer entity)
         {
-            var existing = await _documentRepository.FindOneAsync(e => e.Id == entity.Id);
+            var existing = await FindOneAsync(e => e.Id == entity.Id);
             if (existing != null) return null;
             entity.SequenceNumber = 1;
             entity.ETag = Guid.NewGuid().ToString();
-            return await _documentRepository.InsertOneAsync(entity);
+            return await InsertOneAsync(entity);
         }
 
-        public async Task<Customer> Update(Customer entity)
+        public async Task<Customer> UpdateAsync(Customer entity)
         {
-            var existing = await Get(entity.Id);
+            var existing = await GetAsync(entity.Id);
             if (existing == null) return null;
             if (string.Compare(entity.ETag, existing.ETag, StringComparison.OrdinalIgnoreCase) != 0 )
                 throw new ConcurrencyException();
             entity.SequenceNumber = existing.SequenceNumber + 1;
             entity.ETag = Guid.NewGuid().ToString();
-            return await _documentRepository.FindOneAndReplaceAsync(e => e.Id == entity.Id, entity);
+            return await FindOneAndReplaceAsync(e => e.Id == entity.Id, entity);
         }
 
-        public async Task<int> Remove(Guid id) =>
-            await _documentRepository.DeleteOneAsync(e => e.Id == id);
+        public async Task<int> RemoveAsync(Guid id) =>
+            await DeleteOneAsync(e => e.Id == id);
     }
 }
diff --git a/reference-architecture/CustomerService/Repositories/ICustomerRepository.cs b/reference-architecture/CustomerService/Repositories/ICustomerRepository.cs
@@ -7,10 +7,10 @@ namespace CustomerService.Repositories
 {
     public interface ICustomerRepository
     {
-        Task<IEnumerable<Customer>> Get();
-        Task<Customer> Get(Guid id);
-        Task<Customer> Add(Customer entity);
-        Task<Customer> Update(Customer entity);
-        Task<int> Remove(Guid id);
+        Task<IEnumerable<Customer>> GetAsync();
+        Task<Customer> GetAsync(Guid id);
+        Task<Customer> AddAsync(Customer entity);
+        Task<Customer> UpdateAsync(Customer entity);
+        Task<int> RemoveAsync(Guid id);
     }
 }
diff --git a/reference-architecture/OrderService/Controllers/OrderQueryController.cs b/reference-architecture/OrderService/Controllers/OrderQueryController.cs
@@ -25,7 +25,7 @@ public OrderQueryController(IOrderRepository repository)
         [HttpGet]
         public async Task<IActionResult> GetOrders()
         {
-            var orders = await _repository.GetOrders();
+            var orders = await _repository.GetAsync();
             var result = GetOrderViews(orders);
             return Ok(result);
         }
@@ -35,7 +35,7 @@ public async Task<IActionResult> GetOrders()
         [Route("customer/{id}")]
         public async Task<IActionResult> GetOrders([FromRoute] Guid id)
         {
-            var orders = await _repository.GetCustomerOrders(id);
+            var orders = await _repository.GetByCustomerAsync(id);
             var result = GetOrderViews(orders);
             return Ok(result);
         }
@@ -45,7 +45,7 @@ public async Task<IActionResult> GetOrders([FromRoute] Guid id)
         [Route("{id}")]
         public async Task<IActionResult> GetOrder([FromRoute] Guid id)
         {
-            var order = await _repository.GetOrder(id);
+            var order = await _repository.GetAsync(id);
             var result = GetOrderViews
                 (Enumerable.Repeat(order, 1)).Single();
             return Ok(result);
diff --git a/reference-architecture/OrderService/Domain/OrderAggregate/CommandHandlers/OrderCommandHandler.cs b/reference-architecture/OrderService/Domain/OrderAggregate/CommandHandlers/OrderCommandHandler.cs
@@ -34,7 +34,7 @@ public async Task<CommandResult<Order>> Handle(CreateOrder command)
             command.Entity.Apply(domainEvent);
             
             // Persist entity
-            var entity = await _repository.AddOrder(command.Entity);
+            var entity = await _repository.AddAsync(command.Entity);
             if (entity == null) return new CommandResult<Order>(CommandOutcome.InvalidCommand);
             return new CommandResult<Order>(CommandOutcome.Accepted, entity);
         }
@@ -46,7 +46,7 @@ public async Task<CommandResult<Order>> Handle(UpdateOrder command)
             try
             {
                 // Persist entity
-                var entity = await _repository.UpdateOrder(command.Entity);
+                var entity = await _repository.UpdateAsync(command.Entity);
                 if (entity == null) return new CommandResult<Order>(CommandOutcome.NotFound);
                 return new CommandResult<Order>(CommandOutcome.Accepted, entity);
             }
@@ -60,15 +60,15 @@ public async Task<CommandResult<Order>> Handle(RemoveOrder command)
         {
             // Persist entity
             _logger.LogInformation("Handling command: {CommandName}", nameof(RemoveOrder));
-            await _repository.RemoveOrder(command.EntityId);
+            await _repository.RemoveAsync(command.EntityId);
             return new CommandResult<Order>(CommandOutcome.Accepted);
         }
 
         public async Task<CommandResult<Order>> Handle(ShipOrder command)
         {
             // Process command
             _logger.LogInformation("Handling command: {CommandName}", nameof(ShipOrder));
-            var entity = await _repository.GetOrder(command.EntityId);
+            var entity = await _repository.GetAsync(command.EntityId);
             if (entity == null) return new CommandResult<Order>(CommandOutcome.NotFound);
             var domainEvent = entity.Process(command);
             
@@ -78,7 +78,7 @@ public async Task<CommandResult<Order>> Handle(ShipOrder command)
             try
             {
                 // Persist entity
-                var order = await _repository.UpdateOrderState(entity, OrderState.Shipped);
+                var order = await _repository.UpdateOrderStateAsync(entity, OrderState.Shipped);
                 if (order == null) return new CommandResult<Order>(CommandOutcome.NotFound);
                 return new CommandResult<Order>(CommandOutcome.Accepted, order);
             }
@@ -92,7 +92,7 @@ public async Task<CommandResult<Order>> Handle(CancelOrder command)
         {
             // Process command
             _logger.LogInformation("Handling command: {CommandName}", nameof(CancelOrder));
-            var entity = await _repository.GetOrder(command.EntityId);
+            var entity = await _repository.GetAsync(command.EntityId);
             if (entity == null) return new CommandResult<Order>(CommandOutcome.NotFound);
             var domainEvent = entity.Process(command);
             
@@ -102,7 +102,7 @@ public async Task<CommandResult<Order>> Handle(CancelOrder command)
             try
             {
                 // Persist entity
-                var order = await _repository.UpdateOrderState(entity, OrderState.Cancelled);
+                var order = await _repository.UpdateOrderStateAsync(entity, OrderState.Cancelled);
                 if (order == null) return new CommandResult<Order>(CommandOutcome.NotFound);
                 return new CommandResult<Order>(CommandOutcome.Accepted, order);
             }
diff --git a/reference-architecture/OrderService/Integration/EventHandlers/CustomerAddressUpdatedEventHandler.cs b/reference-architecture/OrderService/Integration/EventHandlers/CustomerAddressUpdatedEventHandler.cs
@@ -26,11 +26,11 @@ public CustomerAddressUpdatedEventHandler(IOrderRepository orderRepository,
         public override async Task HandleAsync(CustomerAddressUpdated @event)
         {
             _logger.LogInformation("Handling CustomerAddressUpdated event");
-            var orders = await _orderRepository.GetCustomerOrders(@event.CustomerId);
+            var orders = await _orderRepository.GetByCustomerAsync(@event.CustomerId);
             foreach (var order in orders)
             {
                 var shippingAddress = _mapper.Map<Address>(@event.ShippingAddress);
-                await _orderRepository.UpdateOrderAddress(order.Id, shippingAddress);
+                await _orderRepository.UpdateAddressAsync(order.Id, shippingAddress);
             }
         }
     }
diff --git a/reference-architecture/OrderService/Repositories/IOrderRepository.cs b/reference-architecture/OrderService/Repositories/IOrderRepository.cs
@@ -7,13 +7,13 @@ namespace OrderService.Repositories
 {
     public interface IOrderRepository
     {
-        Task<IEnumerable<Order>> GetOrders();
-        Task<IEnumerable<Order>> GetCustomerOrders(Guid customerId);
-        Task<Order> GetOrder(Guid id);
-        Task<Order> AddOrder(Order entity);
-        Task<Order> UpdateOrder(Order entity);
-        Task<Order> UpdateOrderAddress(Guid orderId, Address address);
-        Task<int> RemoveOrder(Guid id);
-        Task<Order> UpdateOrderState(Order entity, OrderState orderState);
+        Task<IEnumerable<Order>> GetAsync();
+        Task<IEnumerable<Order>> GetByCustomerAsync(Guid customerId);
+        Task<Order> GetAsync(Guid id);
+        Task<Order> AddAsync(Order entity);
+        Task<Order> UpdateAsync(Order entity);
+        Task<Order> UpdateAddressAsync(Guid orderId, Address address);
+        Task<int> RemoveAsync(Guid id);
+        Task<Order> UpdateOrderStateAsync(Order entity, OrderState orderState);
     }
 }
diff --git a/reference-architecture/OrderService/Repositories/OrderRepository.cs b/reference-architecture/OrderService/Repositories/OrderRepository.cs
@@ -2,73 +2,68 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using MongoDB.Driver;
 using OrderService.Domain.OrderAggregate;
 using URF.Core.Abstractions;
+using URF.Core.Mongo;
 
 namespace OrderService.Repositories
 {
-    public class OrderRepository : IOrderRepository
+    public class OrderRepository : DocumentRepository<Order>, IOrderRepository
     {
-        private readonly IDocumentRepository<Order> _documentRepository;
-        private readonly ILogger<OrderRepository> _logger;
-
-        public OrderRepository(
-            IDocumentRepository<Order> documentRepository,
-            ILogger<OrderRepository> logger)
+        public OrderRepository(IMongoCollection<Order> collection) : base(collection)
         {
-            _documentRepository = documentRepository;
-            _logger = logger;
         }
-        public async Task<IEnumerable<Order>> GetOrders() => 
-            await _documentRepository.FindManyAsync();
+        public async Task<IEnumerable<Order>> GetAsync() => 
+            await FindManyAsync();
 
-        public async Task<IEnumerable<Order>> GetCustomerOrders(Guid customerId) =>
-            await _documentRepository.FindManyAsync(e => e.CustomerId == customerId);
+        public async Task<IEnumerable<Order>> GetByCustomerAsync(Guid customerId) =>
+            await FindManyAsync(e => e.CustomerId == customerId);
 
-        public async Task<Order> GetOrder(Guid id) =>
-            await _documentRepository.FindOneAsync(e => e.Id == id);
+        public async Task<Order> GetAsync(Guid id) =>
+            await FindOneAsync(e => e.Id == id);
 
-        public async Task<Order> AddOrder(Order entity)
+        public async Task<Order> AddAsync(Order entity)
         {
-            var existing = await _documentRepository.FindOneAsync(e => e.Id == entity.Id);
+            var existing = await FindOneAsync(e => e.Id == entity.Id);
             if (existing != null) return null;
             entity.SequenceNumber = 1;
             entity.ETag = Guid.NewGuid().ToString();
-            return await _documentRepository.InsertOneAsync(entity);
+            return await InsertOneAsync(entity);
         }
 
-        public async Task<Order> UpdateOrder(Order entity)
+        public async Task<Order> UpdateAsync(Order entity)
         {
-            var existing = await GetOrder(entity.Id);
+            var existing = await GetAsync(entity.Id);
             if (existing == null) return null;
             if (string.Compare(entity.ETag, existing.ETag, StringComparison.OrdinalIgnoreCase) != 0 )
                 throw new ConcurrencyException();
             entity.SequenceNumber = existing.SequenceNumber + 1;
             entity.ETag = Guid.NewGuid().ToString();
-            return await _documentRepository.FindOneAndReplaceAsync(e => e.Id == entity.Id, entity);
+            return await FindOneAndReplaceAsync(e => e.Id == entity.Id, entity);
         }
 
-        public async Task<Order> UpdateOrderAddress(Guid orderId, Address address)
+        public async Task<Order> UpdateAddressAsync(Guid orderId, Address address)
         {
-            var existing = await GetOrder(orderId);
+            var existing = await GetAsync(orderId);
             if (existing == null) return null;
             existing.ShippingAddress = address;
-            return await _documentRepository.FindOneAndReplaceAsync(e => e.Id == orderId, existing);
+            return await FindOneAndReplaceAsync(e => e.Id == orderId, existing);
         }
 
-        public async Task<int> RemoveOrder(Guid id) =>
-            await _documentRepository.DeleteOneAsync(e => e.Id == id);
+        public async Task<int> RemoveAsync(Guid id) =>
+            await DeleteOneAsync(e => e.Id == id);
 
-        public async Task<Order> UpdateOrderState(Order entity, OrderState orderState)
+        public async Task<Order> UpdateOrderStateAsync(Order entity, OrderState orderState)
         {
-            var existing = await GetOrder(entity.Id);
+            var existing = await GetAsync(entity.Id);
             if (existing == null) return null;
             if (string.Compare(entity.ETag, existing.ETag, StringComparison.OrdinalIgnoreCase) != 0 )
                 throw new ConcurrencyException();
             entity.SequenceNumber++;
             entity.ETag = Guid.NewGuid().ToString();
             entity.OrderState = orderState;
-            return await _documentRepository.FindOneAndReplaceAsync(e => e.Id == entity.Id, entity);
+            return await FindOneAndReplaceAsync(e => e.Id == entity.Id, entity);
         }
     }
 }
diff --git a/test/EventDriven.CQRS.Tests/CustomerCommandControllerTests.cs b/test/EventDriven.CQRS.Tests/CustomerCommandControllerTests.cs
@@ -78,7 +78,7 @@ public async Task Remove_Removes_Customer()
             
             // Assert
             Assert.IsType<NoContentResult>(actionResult);
-            var value = await repository.Get(customer.Id);
+            var value = await repository.GetAsync(customer.Id);
             Assert.Null(value);
         }
     }
diff --git a/test/EventDriven.CQRS.Tests/Fakes/FakeCustomerRepository.cs b/test/EventDriven.CQRS.Tests/Fakes/FakeCustomerRepository.cs
diff --git a/test/EventDriven.CQRS.Tests/Fakes/FakeOrderRepository.cs b/test/EventDriven.CQRS.Tests/Fakes/FakeOrderRepository.cs
diff --git a/test/EventDriven.CQRS.Tests/OrderCommandControllerTests.cs b/test/EventDriven.CQRS.Tests/OrderCommandControllerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public CustomerQueryController(ICustomerRepository repository, IMapper mapper)`
`25`	`25`	`[HttpGet]`
`26`	`26`	`public async Task<IActionResult> GetCustomers()`
`27`	`27`	`{`
`28`		`- var customers = await _repository.Get();`
	`28`	`+ var customers = await _repository.GetAsync();`
`29`	`29`	`var result = _mapper.Map<IEnumerable<CustomerView>>(customers);`
`30`	`30`	`return Ok(result);`
`31`	`31`	`}`
`@@ -35,7 +35,7 @@ public async Task<IActionResult> GetCustomers()`
`35`	`35`	`[Route("{id}")]`
`36`	`36`	`public async Task<IActionResult> GetCustomer([FromRoute] Guid id)`
`37`	`37`	`{`
`38`		`- var customer = await _repository.Get(id);`
	`38`	`+ var customer = await _repository.GetAsync(id);`
`39`	`39`	`if (customer == null) return NotFound();`
`40`	`40`	`var result = _mapper.Map<CustomerView>(customer);`
`41`	`41`	`return Ok(result);`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public async Task<CommandResult<Customer>> Handle(CreateCustomer command)`
`42`	`42`	`command.Entity.Apply(domainEvent);`
`43`	`43`
`44`	`44`	`// Persist entity`
`45`		`- var entity = await _repository.Add(command.Entity);`
	`45`	`+ var entity = await _repository.AddAsync(command.Entity);`
`46`	`46`	`if (entity == null) return new CommandResult<Customer>(CommandOutcome.InvalidCommand);`
`47`	`47`	`return new CommandResult<Customer>(CommandOutcome.Accepted, entity);`
`48`	`48`	`}`
`@@ -51,14 +51,14 @@ public async Task<CommandResult<Customer>> Handle(UpdateCustomer command)`
`51`	`51`	`{`
`52`	`52`	`// Compare shipping addresses`
`53`	`53`	`_logger.LogInformation("Handling command: {CommandName}", nameof(UpdateCustomer));`
`54`		`- var existing = await _repository.Get(command.EntityId);`
	`54`	`+ var existing = await _repository.GetAsync(command.EntityId);`
`55`	`55`	`if (existing == null) return new CommandResult<Customer>(CommandOutcome.NotHandled);`
`56`	`56`	`var addressChanged = command.Entity.ShippingAddress != existing.ShippingAddress;`
`57`	`57`
`58`	`58`	`try`
`59`	`59`	`{`
`60`	`60`	`// Persist entity`
`61`		`- var entity = await _repository.Update(command.Entity);`
	`61`	`+ var entity = await _repository.UpdateAsync(command.Entity);`
`62`	`62`	`if (entity == null) return new CommandResult<Customer>(CommandOutcome.NotFound);`
`63`	`63`
`64`	`64`	`// Publish events`
`@@ -82,7 +82,7 @@ public async Task<CommandResult<Customer>> Handle(RemoveCustomer command)`
`82`	`82`	`{`
`83`	`83`	`// Persist entity`
`84`	`84`	`_logger.LogInformation("Handling command: {CommandName}", nameof(RemoveCustomer));`
`85`		`- await _repository.Remove(command.EntityId);`
	`85`	`+ await _repository.RemoveAsync(command.EntityId);`
`86`	`86`	`return new CommandResult<Customer>(CommandOutcome.Accepted);`
`87`	`87`	`}`
`88`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ namespace CustomerService.Repositories`
`7`	`7`	`{`
`8`	`8`	`public interface ICustomerRepository`
`9`	`9`	`{`
`10`		`- Task<IEnumerable<Customer>> Get();`
`11`		`- Task<Customer> Get(Guid id);`
`12`		`- Task<Customer> Add(Customer entity);`
`13`		`- Task<Customer> Update(Customer entity);`
`14`		`- Task<int> Remove(Guid id);`
	`10`	`+ Task<IEnumerable<Customer>> GetAsync();`
	`11`	`+ Task<Customer> GetAsync(Guid id);`
	`12`	`+ Task<Customer> AddAsync(Customer entity);`
	`13`	`+ Task<Customer> UpdateAsync(Customer entity);`
	`14`	`+ Task<int> RemoveAsync(Guid id);`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public OrderQueryController(IOrderRepository repository)`
`25`	`25`	`[HttpGet]`
`26`	`26`	`public async Task<IActionResult> GetOrders()`
`27`	`27`	`{`
`28`		`- var orders = await _repository.GetOrders();`
	`28`	`+ var orders = await _repository.GetAsync();`
`29`	`29`	`var result = GetOrderViews(orders);`
`30`	`30`	`return Ok(result);`
`31`	`31`	`}`
`@@ -35,7 +35,7 @@ public async Task<IActionResult> GetOrders()`
`35`	`35`	`[Route("customer/{id}")]`
`36`	`36`	`public async Task<IActionResult> GetOrders([FromRoute] Guid id)`
`37`	`37`	`{`
`38`		`- var orders = await _repository.GetCustomerOrders(id);`
	`38`	`+ var orders = await _repository.GetByCustomerAsync(id);`
`39`	`39`	`var result = GetOrderViews(orders);`
`40`	`40`	`return Ok(result);`
`41`	`41`	`}`
`@@ -45,7 +45,7 @@ public async Task<IActionResult> GetOrders([FromRoute] Guid id)`
`45`	`45`	`[Route("{id}")]`
`46`	`46`	`public async Task<IActionResult> GetOrder([FromRoute] Guid id)`
`47`	`47`	`{`
`48`		`- var order = await _repository.GetOrder(id);`
	`48`	`+ var order = await _repository.GetAsync(id);`
`49`	`49`	`var result = GetOrderViews`
`50`	`50`	`(Enumerable.Repeat(order, 1)).Single();`
`51`	`51`	`return Ok(result);`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public async Task<CommandResult<Order>> Handle(CreateOrder command)`
`34`	`34`	`command.Entity.Apply(domainEvent);`
`35`	`35`
`36`	`36`	`// Persist entity`
`37`		`- var entity = await _repository.AddOrder(command.Entity);`
	`37`	`+ var entity = await _repository.AddAsync(command.Entity);`
`38`	`38`	`if (entity == null) return new CommandResult<Order>(CommandOutcome.InvalidCommand);`
`39`	`39`	`return new CommandResult<Order>(CommandOutcome.Accepted, entity);`
`40`	`40`	`}`
`@@ -46,7 +46,7 @@ public async Task<CommandResult<Order>> Handle(UpdateOrder command)`
`46`	`46`	`try`
`47`	`47`	`{`
`48`	`48`	`// Persist entity`
`49`		`- var entity = await _repository.UpdateOrder(command.Entity);`
	`49`	`+ var entity = await _repository.UpdateAsync(command.Entity);`
`50`	`50`	`if (entity == null) return new CommandResult<Order>(CommandOutcome.NotFound);`
`51`	`51`	`return new CommandResult<Order>(CommandOutcome.Accepted, entity);`
`52`	`52`	`}`
`@@ -60,15 +60,15 @@ public async Task<CommandResult<Order>> Handle(RemoveOrder command)`
`60`	`60`	`{`
`61`	`61`	`// Persist entity`
`62`	`62`	`_logger.LogInformation("Handling command: {CommandName}", nameof(RemoveOrder));`
`63`		`- await _repository.RemoveOrder(command.EntityId);`
	`63`	`+ await _repository.RemoveAsync(command.EntityId);`
`64`	`64`	`return new CommandResult<Order>(CommandOutcome.Accepted);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`public async Task<CommandResult<Order>> Handle(ShipOrder command)`
`68`	`68`	`{`
`69`	`69`	`// Process command`
`70`	`70`	`_logger.LogInformation("Handling command: {CommandName}", nameof(ShipOrder));`
`71`		`- var entity = await _repository.GetOrder(command.EntityId);`
	`71`	`+ var entity = await _repository.GetAsync(command.EntityId);`
`72`	`72`	`if (entity == null) return new CommandResult<Order>(CommandOutcome.NotFound);`
`73`	`73`	`var domainEvent = entity.Process(command);`
`74`	`74`
`@@ -78,7 +78,7 @@ public async Task<CommandResult<Order>> Handle(ShipOrder command)`
`78`	`78`	`try`
`79`	`79`	`{`
`80`	`80`	`// Persist entity`
`81`		`- var order = await _repository.UpdateOrderState(entity, OrderState.Shipped);`
	`81`	`+ var order = await _repository.UpdateOrderStateAsync(entity, OrderState.Shipped);`
`82`	`82`	`if (order == null) return new CommandResult<Order>(CommandOutcome.NotFound);`
`83`	`83`	`return new CommandResult<Order>(CommandOutcome.Accepted, order);`
`84`	`84`	`}`
`@@ -92,7 +92,7 @@ public async Task<CommandResult<Order>> Handle(CancelOrder command)`
`92`	`92`	`{`
`93`	`93`	`// Process command`
`94`	`94`	`_logger.LogInformation("Handling command: {CommandName}", nameof(CancelOrder));`
`95`		`- var entity = await _repository.GetOrder(command.EntityId);`
	`95`	`+ var entity = await _repository.GetAsync(command.EntityId);`
`96`	`96`	`if (entity == null) return new CommandResult<Order>(CommandOutcome.NotFound);`
`97`	`97`	`var domainEvent = entity.Process(command);`
`98`	`98`
`@@ -102,7 +102,7 @@ public async Task<CommandResult<Order>> Handle(CancelOrder command)`
`102`	`102`	`try`
`103`	`103`	`{`
`104`	`104`	`// Persist entity`
`105`		`- var order = await _repository.UpdateOrderState(entity, OrderState.Cancelled);`
	`105`	`+ var order = await _repository.UpdateOrderStateAsync(entity, OrderState.Cancelled);`
`106`	`106`	`if (order == null) return new CommandResult<Order>(CommandOutcome.NotFound);`
`107`	`107`	`return new CommandResult<Order>(CommandOutcome.Accepted, order);`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,11 +26,11 @@ public CustomerAddressUpdatedEventHandler(IOrderRepository orderRepository,`
`26`	`26`	`public override async Task HandleAsync(CustomerAddressUpdated @event)`
`27`	`27`	`{`
`28`	`28`	`_logger.LogInformation("Handling CustomerAddressUpdated event");`
`29`		`- var orders = await _orderRepository.GetCustomerOrders(@event.CustomerId);`
	`29`	`+ var orders = await _orderRepository.GetByCustomerAsync(@event.CustomerId);`
`30`	`30`	`foreach (var order in orders)`
`31`	`31`	`{`
`32`	`32`	`var shippingAddress = _mapper.Map<Address>(@event.ShippingAddress);`
`33`		`- await _orderRepository.UpdateOrderAddress(order.Id, shippingAddress);`
	`33`	`+ await _orderRepository.UpdateAddressAsync(order.Id, shippingAddress);`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,13 @@ namespace OrderService.Repositories`
`7`	`7`	`{`
`8`	`8`	`public interface IOrderRepository`
`9`	`9`	`{`
`10`		`- Task<IEnumerable<Order>> GetOrders();`
`11`		`- Task<IEnumerable<Order>> GetCustomerOrders(Guid customerId);`
`12`		`- Task<Order> GetOrder(Guid id);`
`13`		`- Task<Order> AddOrder(Order entity);`
`14`		`- Task<Order> UpdateOrder(Order entity);`
`15`		`- Task<Order> UpdateOrderAddress(Guid orderId, Address address);`
`16`		`- Task<int> RemoveOrder(Guid id);`
`17`		`- Task<Order> UpdateOrderState(Order entity, OrderState orderState);`
	`10`	`+ Task<IEnumerable<Order>> GetAsync();`
	`11`	`+ Task<IEnumerable<Order>> GetByCustomerAsync(Guid customerId);`
	`12`	`+ Task<Order> GetAsync(Guid id);`
	`13`	`+ Task<Order> AddAsync(Order entity);`
	`14`	`+ Task<Order> UpdateAsync(Order entity);`
	`15`	`+ Task<Order> UpdateAddressAsync(Guid orderId, Address address);`
	`16`	`+ Task<int> RemoveAsync(Guid id);`
	`17`	`+ Task<Order> UpdateOrderStateAsync(Order entity, OrderState orderState);`
`18`	`18`	`}`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public async Task Remove_Removes_Customer()`
`78`	`78`
`79`	`79`	`// Assert`
`80`	`80`	`Assert.IsType<NoContentResult>(actionResult);`
`81`		`- var value = await repository.Get(customer.Id);`
	`81`	`+ var value = await repository.GetAsync(customer.Id);`
`82`	`82`	`Assert.Null(value);`
`83`	`83`	`}`
`84`	`84`	`}`