Merge pull request #51 from SWD392-Domus/feature/products-management

Feature: products management

Domus.Api/Controllers/ProductsController.cs

@@ -12,7 +12,7 @@ namespace Domus.Api.Controllers;
 [Route("api/[controller]")]
 public class ProductsController : BaseApiController
 {
-	private IProductService _productService;
+	private readonly IProductService _productService;
 
 	public ProductsController(IProductService productService)
 	{
@@ -69,4 +69,12 @@ public async Task<IActionResult> DeleteProduct(Guid id)
 			async () => await _productService.DeleteProduct(id).ConfigureAwait(false)
 		).ConfigureAwait(false);
 	}
+
+	[HttpDelete("multiple")]
+	public async Task<IActionResult> DeleteMultipleProducts(IEnumerable<Guid> ids)
+	{
+		return await ExecuteServiceLogic(
+			async () => await _productService.DeleteMultipleProducts(ids).ConfigureAwait(false)
+		).ConfigureAwait(false);
+	}
 }

Domus.DAL/Implementations/ProductRepository.cs

@@ -1,11 +1,21 @@
+using System.Linq.Expressions;
 using Domus.DAL.Interfaces;
 using Domus.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
 
 namespace Domus.DAL.Implementations;
 
 public class ProductRepository : GenericRepository<Product>, IProductRepository
 {
+    private readonly DbSet<Product> _dbSet;
     public ProductRepository(IAppDbContext dbContext) : base(dbContext)
     {
+        _dbSet = dbContext.CreateSet<Product>();
+    }
+
+    public new async Task DeleteManyAsync(Expression<Func<Product, bool>> predicate)
+    {
+        var entities = _dbSet.Where(predicate);
+        await entities.ForEachAsync(p => p.IsDeleted = true);
     }
 }

Domus.DAL/Interfaces/IProductRepository.cs

@@ -1,8 +1,10 @@
+using System.Linq.Expressions;
 using Domus.Common.Interfaces;
 using Domus.Domain.Entities;
 
 namespace Domus.DAL.Interfaces;
 
 public interface IProductRepository : IGenericRepository<Product>, IAutoRegisterable
 {
+    new Task DeleteManyAsync(Expression<Func<Product, bool>> predicate);
 }

Domus.Domain/Dtos/Products/DtoProduct.cs

@@ -12,6 +12,8 @@ public class DtoProduct
 
     public string? Description { get; set; }
 
+	public int TotalQuantity { get; set; }
+
 	[JsonPropertyName("category")]
     public DtoProductCategory ProductCategory { get; set; } = null!;
 

Domus.Domain/Entities/Product.cs

@@ -2,7 +2,7 @@
 
 namespace Domus.Domain.Entities;
 
-public partial class Product : BaseEntity<Guid>
+public partial class Product : DeletableEntity<Guid>
 {
     public Guid ProductCategoryId { get; set; }
 
@@ -12,8 +12,6 @@ public partial class Product : BaseEntity<Guid>
 
     public string? Description { get; set; }
 
-    public bool? IsDeleted { get; set; }
-
     public string? ConcurrencyStamp { get; set; }
 
     public virtual ProductCategory ProductCategory { get; set; } = null!;

Domus.Service/Implementations/ProductDetailService.cs

@@ -1,4 +1,3 @@
-using System.Collections;
 using AutoMapper;
 using AutoMapper.QueryableExtensions;
 using Domus.Common.Helpers;
@@ -19,25 +18,19 @@ public class ProductDetailService : IProductDetailService
 	private readonly IProductRepository _productRepository;
 	private readonly IMapper _mapper;
 	private readonly IUnitOfWork _unitOfWork;
-	private readonly IProductPriceRepository _productPriceRepository;
-	private readonly IProductAttributeValueRepository _productAttributeValueRepository;
 	private readonly IProductAttributeRepository _productAttributeRepository;
 
 	public ProductDetailService(
 			IProductDetailRepository productDetailRepository,
 			IMapper mapper,
 			IUnitOfWork unitOfWork,
 			IProductRepository productRepository,
-			IProductPriceRepository productPriceRepository,
-			IProductAttributeValueRepository productAttributeValueRepository,
 			IProductAttributeRepository productAttributeRepository)
 	{
 		_productDetailRepository = productDetailRepository;
 		_mapper = mapper;
 		_unitOfWork = unitOfWork;
 		_productRepository = productRepository;
-		_productPriceRepository = productPriceRepository;
-		_productAttributeValueRepository = productAttributeValueRepository;
 		_productAttributeRepository = productAttributeRepository;
 	}
 

Domus.Service/Implementations/ProductService.cs

@@ -47,7 +47,7 @@ public async Task<ServiceActionResult> CreateProduct(CreateProductRequest reques
 
     public async Task<ServiceActionResult> DeleteProduct(Guid id)
     {
-		var product = await _productRepository.GetAsync(p => p.Id == id);
+		var product = await _productRepository.GetAsync(p => !p.IsDeleted && p.Id == id);
 		if (product is null)
 			throw new ProductNotFoundException();
 
@@ -60,33 +60,50 @@ public async Task<ServiceActionResult> DeleteProduct(Guid id)
 
     public async Task<ServiceActionResult> GetAllProducts()
     {
-		var products = await (await _productRepository.GetAllAsync()).ProjectTo<DtoProduct>(_mapper.ConfigurationProvider)
+		var products = await (await _productRepository.GetAllAsync())
+			.Where(p => !p.IsDeleted)
+			.ProjectTo<DtoProduct>(_mapper.ConfigurationProvider)
 			.ToListAsync();
+
+		foreach (var product in products)
+		{
+			product.TotalQuantity = (int)product.ProductDetails.Sum(d => d.ProductPrices.Sum(p => p.Quantity));
+		}
 
 		return new ServiceActionResult(true) { Data = products };
     }
 
     public async Task<ServiceActionResult> GetPaginatedProducts(BasePaginatedRequest request)
     {
-		var queryableProducts = (await _productRepository.GetAllAsync()).ProjectTo<DtoProduct>(_mapper.ConfigurationProvider);
+		var queryableProducts = (await _productRepository.GetAllAsync())
+			.Where(p => !p.IsDeleted)
+			.ProjectTo<DtoProduct>(_mapper.ConfigurationProvider);
 		var paginatedResult = PaginationHelper.BuildPaginatedResult(queryableProducts, request.PageSize, request.PageIndex);
+		var products = await ((IQueryable<DtoProduct>)paginatedResult.Items!).ToListAsync();
+
+		foreach (var product in products)
+		{
+			product.TotalQuantity = (int)product.ProductDetails.Sum(d => d.ProductPrices.Sum(p => p.Quantity));
+		}
+
+		paginatedResult.Items = products;
 
 		return new ServiceActionResult(true) { Data = paginatedResult };
     }
 
     public async Task<ServiceActionResult> GetProduct(Guid id)
     {
 		var product = await (await _productRepository.GetAllAsync())
+			.Where(p => !p.IsDeleted && p.Id == id)
 			.ProjectTo<DtoProductWithoutCategory>(_mapper.ConfigurationProvider)
-			.Where(p => p.Id == id)
 			.FirstOrDefaultAsync() ?? throw new ProductNotFoundException();
 
 		return new ServiceActionResult(true) { Data = product };
     }
 
     public async Task<ServiceActionResult> UpdateProduct(UpdateProductRequest request, Guid id)
     {
-		var product = await _productRepository.GetAsync(p => p.Id == id);
+		var product = await _productRepository.GetAsync(p => !p.IsDeleted && p.Id == id);
 		if (product is null)
 			throw new ProductNotFoundException();
 		if (!await _productCategoryRepository.ExistsAsync(c => c.Id == request.ProductCategoryId))
@@ -98,4 +115,12 @@ public async Task<ServiceActionResult> UpdateProduct(UpdateProductRequest reques
 
 		return new ServiceActionResult(true);
     }
+
+    public async Task<ServiceActionResult> DeleteMultipleProducts(IEnumerable<Guid> ids)
+    {
+	    await _productRepository.DeleteManyAsync(p => !p.IsDeleted && ids.Contains(p.Id));
+	    await _unitOfWork.CommitAsync();
+
+	    return new ServiceActionResult(true) { Detail = "Products deleted successfully"};
+    }
 }

Domus.Service/Interfaces/IProductService.cs

@@ -13,4 +13,5 @@ public interface IProductService : IAutoRegisterable
     Task<ServiceActionResult> GetPaginatedProducts(BasePaginatedRequest request);
     Task<ServiceActionResult> GetProduct(Guid id);
     Task<ServiceActionResult> UpdateProduct(UpdateProductRequest request, Guid id);
+    Task<ServiceActionResult> DeleteMultipleProducts(IEnumerable<Guid> ids);
 }