Close #26: Use IProductInventoryProvider to get real inventories

modules/EasyAbp.EShop.Products/src/EasyAbp.EShop.Products.Application/EasyAbp/EShop/Products/Products/ProductAppService.cs

@@ -25,6 +25,7 @@ namespace EasyAbp.EShop.Products.Products
         protected override string GetListPolicyName { get; set; } = null;
 
         private readonly IProductManager _productManager;
+        private readonly IProductInventoryProvider _productInventoryProvider;
         private readonly IAttributeOptionIdsSerializer _attributeOptionIdsSerializer;
         private readonly IProductStoreRepository _productStoreRepository;
         private readonly IProductCategoryRepository _productCategoryRepository;
@@ -32,12 +33,14 @@ namespace EasyAbp.EShop.Products.Products
 
         public ProductAppService(
             IProductManager productManager,
+            IProductInventoryProvider productInventoryProvider,
             IAttributeOptionIdsSerializer attributeOptionIdsSerializer,
             IProductStoreRepository productStoreRepository,
             IProductCategoryRepository productCategoryRepository,
             IProductRepository repository) : base(repository)
         {
             _productManager = productManager;
+            _productInventoryProvider = productInventoryProvider;
             _attributeOptionIdsSerializer = attributeOptionIdsSerializer;
             _productStoreRepository = productStoreRepository;
             _productCategoryRepository = productCategoryRepository;
@@ -211,21 +214,37 @@ namespace EasyAbp.EShop.Products.Products
         
         public virtual async Task<ProductDto> GetAsync(Guid id, Guid storeId)
         {
-            var dto = await base.GetAsync(id);
+            await CheckGetPolicyAsync();
 
+            var product = await GetEntityByIdAsync(id);
+            
+            var dto = MapToGetOutputDto(product);
+            
             if (!dto.IsPublished)
             {
                 await CheckStoreIsProductOwnerAsync(id, storeId);
             }
             
-            // Todo: get real inventory.
-
+            await LoadRealInventoriesAsync(product, dto, storeId);
+            
             dto.CategoryIds = (await _productCategoryRepository.GetListByProductIdAsync(dto.Id))
                 .Select(x => x.CategoryId).ToList();
             
             return dto;
         }
 
+        protected virtual async Task<ProductDto> LoadRealInventoriesAsync(Product product, ProductDto productDto, Guid storeId)
+        {
+            var inventoryDict = await _productInventoryProvider.GetInventoryDictionaryAsync(product, storeId);
+
+            foreach (var productSkuDto in productDto.ProductSkus)
+            {
+                productSkuDto.Inventory = inventoryDict[productSkuDto.Id];
+            }
+
+            return productDto;
+        }
+
         public override async Task<PagedResultDto<ProductDto>> GetListAsync(GetProductListDto input)
         {
             await CheckGetListPolicyAsync();
@@ -250,14 +269,16 @@ namespace EasyAbp.EShop.Products.Products
             query = ApplySorting(query, input);
             query = ApplyPaging(query, input);
 
-            var entities = await AsyncQueryableExecuter.ToListAsync(query);
+            var products = await AsyncQueryableExecuter.ToListAsync(query);
 
-            // Todo: get real inventory.
+            var items = new List<ProductDto>();
+            
+            foreach (var product in products)
+            {
+                items.Add(await LoadRealInventoriesAsync(product, MapToGetListOutputDto(product), input.StoreId));
+            }
             
-            return new PagedResultDto<ProductDto>(
-                totalCount,
-                entities.Select(MapToGetListOutputDto).ToList()
-            );
+            return new PagedResultDto<ProductDto>(totalCount, items);
         }
 
         public async Task DeleteAsync(Guid id, Guid storeId)

modules/EasyAbp.EShop.Products/src/EasyAbp.EShop.Products.Domain/EasyAbp/EShop/Products/Products/DefaultProductInventoryProvider.cs

 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
 
@@ -7,24 +8,29 @@ namespace EasyAbp.EShop.Products.Products
     [Dependency(TryRegister = true)]
     public class DefaultProductInventoryProvider : IProductInventoryProvider, ITransientDependency
     {
-        public virtual async Task<bool> IsInventorySufficientAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
+        public virtual Task<int> GetInventoryAsync(Product product, ProductSku productSku, Guid storeId)
         {
-            var inventory = await GetInventoryAsync(product, productSku, storeId);
-            
-            return product.InventoryStrategy == InventoryStrategy.NoNeed || inventory - quantity >= 0;
+            return Task.FromResult(productSku.Inventory);
         }
 
-        public virtual Task<int> GetInventoryAsync(Product product, ProductSku productSku, Guid storeId)
+        public virtual Task<Dictionary<Guid, int>> GetInventoryDictionaryAsync(Product product, Guid storeId)
         {
-            return Task.FromResult(productSku.Inventory);
+            var dict = new Dictionary<Guid, int>();
+            
+            foreach (var productSku in product.ProductSkus)
+            {
+                dict[productSku.Id] = productSku.Inventory;
+            }
+
+            return Task.FromResult(dict);
         }
 
-        public Task<bool> TryIncreaseInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
+        public virtual Task<bool> TryIncreaseInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
         {
             return Task.FromResult(productSku.TryIncreaseInventory(quantity));
         }
 
-        public Task<bool> TryReduceInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
+        public virtual Task<bool> TryReduceInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
         {
             return Task.FromResult(productSku.TryReduceInventory(quantity));
         }

modules/EasyAbp.EShop.Products/src/EasyAbp.EShop.Products.Domain/EasyAbp/EShop/Products/Products/IProductInventoryProvider.cs

 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace EasyAbp.EShop.Products.Products
 {
     public interface IProductInventoryProvider
     {
-        Task<bool> IsInventorySufficientAsync(Product product, ProductSku productSku, Guid storeId, int quantity);
-        
         Task<int> GetInventoryAsync(Product product, ProductSku productSku, Guid storeId);
+        
+        Task<Dictionary<Guid, int>> GetInventoryDictionaryAsync(Product product, Guid storeId);
 
         Task<bool> TryIncreaseInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity);
         

modules/EasyAbp.EShop.Products/src/EasyAbp.EShop.Products.Domain/EasyAbp/EShop/Products/Products/ProductManager.cs

@@ -16,22 +16,24 @@ namespace EasyAbp.EShop.Products.Products
             _productInventoryProvider = productInventoryProvider;
         }
         
-        public async Task<bool> IsInventorySufficientAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
+        public virtual async Task<bool> IsInventorySufficientAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
         {
-            return await _productInventoryProvider.IsInventorySufficientAsync(product, productSku, storeId, quantity);
+            var inventory = await _productInventoryProvider.GetInventoryAsync(product, productSku, storeId);
+            
+            return product.InventoryStrategy == InventoryStrategy.NoNeed || inventory - quantity >= 0;
         }
 
-        public async Task<int> GetInventoryAsync(Product product, ProductSku productSku, Guid storeId)
+        public virtual async Task<int> GetInventoryAsync(Product product, ProductSku productSku, Guid storeId)
         {
             return await _productInventoryProvider.GetInventoryAsync(product, productSku, storeId);
         }
 
-        public async Task<bool> TryIncreaseInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
+        public virtual async Task<bool> TryIncreaseInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
         {
             return await _productInventoryProvider.TryIncreaseInventoryAsync(product, productSku, storeId, quantity);
         }
 
-        public async Task<bool> TryReduceInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
+        public virtual async Task<bool> TryReduceInventoryAsync(Product product, ProductSku productSku, Guid storeId, int quantity)
         {
             return await _productInventoryProvider.TryReduceInventoryAsync(product, productSku, storeId, quantity);
         }