public async Task <ActionResult> DeleteProductPhoto(int id, int photoId)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);
var photo = product.Photos.SingleOrDefault(x => x.Id == photoId);
if (photo != null)
{
if (photo.IsMain)
{
return(BadRequest(new ApiResponse(400,
"You cannot delete the main photo")));
}
_photoService.DeleteFromDisk(photo);
}
else
{
return(BadRequest(new ApiResponse(400, "Photo does not exist")));
}
product.RemovePhoto(photoId);
_unitOfWork.Repository <Product>().Update(product);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem adding photo product")));
}
return(Ok());
}
//Task<ActionResult<List<ProductToReturnDto cambio el list para que coincida con el metodo
//reemplazamos en paginacion public async Task<ActionResult<IReadOnlyList<ProductToReturnDto>>> GetProducts(
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProducts(
//string sort,int? brandId,int? typeId)// parametros anteriores a paginacion
[FromQuery] ProductSpecParams productParams)
{
//var products = await _productRepo.ListAllAsync();
//var spec = new ProductWithTypesAndBrandsSpecification(sort, brandId, typeId); // Core/Specification agrega los includes
var spec = new ProductWithTypesAndBrandsSpecification(productParams); // Core/Specification agrega los includes
var countSpec = new ProductWithFiltersForCountSpecification(productParams);
var totalItems = await _productRepo.CountAsync(countSpec);
var products = await _productRepo.ListAsync(spec);
var data = _mapper
.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
// return Ok(products);
//return products.Select(products => new ProductToReturnDto
//{
// Id = products.Id,
// Name = products.Name,
// Description = products.Name,
// PictureUrl = products.PictureUrl,
// Price = products.Price,
// ProductBrand = products.ProductBrand.Name,
// ProductType = products.ProductType.Name
//}).ToList();
//return Automapping
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex,
productParams.PageSize, totalItems, data)));
}
public async Task <ProductDto> GetProduct(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _productRepository.GetEntityBySpecification(spec);
return(_mapper.Map <Product, ProductDto>(product));
}
public async Task <ActionResult <WarehouseReceiptToReturnDto> > CreateWarehouseReceipt(WarehouseReceiptDto warehouseReceiptDto)
{
var spec = new ProductWithTypesAndBrandsSpecification(warehouseReceiptDto.ProductId);
var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);
product.AddOrUpdateProductSize(warehouseReceiptDto.Size, warehouseReceiptDto.Quantity);
_unitOfWork.Repository <Product>().Update(product);
var user = await _userManager.FindByEmailFromClaimsPriciple(HttpContext.User);
var receipt = _mapper.Map <WarehouseReceiptDto, WarehouseReceipt>(warehouseReceiptDto);
receipt.AppUserId = user.Id;
receipt.CreatedDate = DateTime.UtcNow;
_unitOfWork.Repository <WarehouseReceipt>().Add(receipt);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem creating receipt")));
}
return(Ok(_mapper.Map <WarehouseReceipt, WarehouseReceiptToReturnDto>(receipt)));
}
public async Task <ActionResult <ProductToReturnDto> > AddProductPhoto(int id, [FromForm] ProductPhotoDto photoDto)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);
if (photoDto.Photo.Length > 0)
{
var photo = await _photoService.SaveToDiskAsync(photoDto.Photo);
if (photo != null)
{
product.AddPhoto(photo.PictureUrl, photo.FileName);
_unitOfWork.Repository <Product>().Update(product);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem adding photo product")));
}
}
else
{
return(BadRequest(new ApiResponse(400, "problem saving photo to disk")));
}
}
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GerProducts(
[FromQuery] ProductSpecParams productParams)
{
var spec = new ProductWithTypesAndBrandsSpecification(productParams);
var countSpec = new ProductWithFiltersForCountSpecificication(productParams);
var totalItems = await _productsRepo.CountAsync(countSpec);
var products = await _productsRepo.ListAsync(spec);
var data = _mapper
.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex, productParams.PageSize, totalItems, data)));
// return product.Select(product => new ProductToReturnDto
// {
// Id = product.Id,
// Name = product.Name,
// Description = product.Description,
// PictureUrl = product.PictureUrl,
// Price = product.Price,
// ProductBrand = product.ProductBrand.Name,
// ProductType = product.ProductType.Name
// }).ToList();
}
public async Task <Order> UpdateOrderAdminAsync(int idOrder, string buyerEmail, int deliveryMethodId, List <BasketItem> orderItems, Address shippingAddress)
{
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethod>().GetByIdAsync(deliveryMethodId);
var spec = new OrdersAllWithItemsAndOrderingSpecification(idOrder);
var orderOld = await _unitOfWork.Repository <Order>().GetEntityWithSpec(spec);
var items = new List <OrderItem>();
foreach (var item in orderItems)
{
var specProduct = new ProductWithTypesAndBrandsSpecification(item.Id);
var productItem = await _unitOfWork.Repository <Product>().GetEntityWithSpec(specProduct);
var itemOrdered = new ProductItemOrdered(productItem.Id, item.Size, productItem.Name,
productItem.Photos.FirstOrDefault(x => x.IsMain)?.PictureUrl);
var productSize = productItem.ProductSizes.FirstOrDefault(x => x.Size == item.Size);
var orderItem = new OrderItem();
orderItem = new OrderItem(itemOrdered, productItem.Price, item.Quantity);
items.Add(orderItem);
}
var subtotal = items.Sum(item => item.Price * item.Quantity);
//var order = new Order(items, buyerEmail, shippingAddress, deliveryMethod, subtotal);
orderOld.OrderItems = items;
orderOld.ShipToAddress = shippingAddress;
orderOld.DeliveryMethod = deliveryMethod;
orderOld.Subtotal = subtotal;
_unitOfWork.Repository <Order>().Update(orderOld);
var result = await _unitOfWork.Complete();
//return order
return(orderOld);
}
public async Task <ActionResult <Pagination <List <ProductToReturnDto> > > > GetProducts([FromQuery] ProductSpecParams productParams)
{
var spec = new ProductWithTypesAndBrandsSpecification(productParams);
var countSpec = new ProductsWithFilterForCountSpecification(productParams);
// var totalItems=await _productsRepo.CountAsync(countSpec);
// var products = await _productsRepo.ListAsync(spec);
// var data=_mapper.Map<IReadOnlyList<Product>,IReadOnlyList<ProductToReturnDto>>(products);
// return Ok( new Pagination<ProductToReturnDto>(productParams.PageIndex,productParams.PageSize,totalItems,data));
var totalItems = await _unitOfWork.Repository <Product>().CountAsync(countSpec);
var products = await _unitOfWork.Repository <Product>().ListAsync(spec);
var data = _mapper
.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex, productParams.PageSize, totalItems, data)));
}
public async Task<ActionResult<ProductToReturnDto>> GetProduct(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _productsRepo.GetEntityWithSpec(spec);
if (product == null) return NotFound(new ApiResponse(404));
return _mapper.Map<Product, ProductToReturnDto>(product);
}
public async Task <ActionResult <ProductToReturnDto> > GetProduct(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _productRepo.GetEntityWithSpec(spec);
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <ActionResult <ProductToReturnDto> > AddOrUpdateProductSize(int id, ProductSizeToCreateDto sizeDto)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);
if (sizeDto != null)
{
// product.AddPhoto(sizeDto.PictureUrl, photo.FileName);
product.AddOrUpdateProductSize(sizeDto.Size, sizeDto.Quantity);
_unitOfWork.Repository <Product>().Update(product);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem adding size product")));
}
}
else
{
return(BadRequest(new ApiResponse(400, "problem saving photo to disk")));
}
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <ActionResult <ProductToReturnDto> > GetProduct(int id)
{
//var products = await _productRepo.getByIdAsync(id);
var spec = new ProductWithTypesAndBrandsSpecification(id);
//return Ok(products);
//return await _productRepo.GetEntityWithSpec(spec);
var producto = await _productRepo.GetEntityWithSpec(spec);
//return new ProductToReturnDto
//{
// Id=producto.Id,
// Name=producto.Name,
// Description = producto.Name,
// PictureUrl = producto.PictureUrl,
// Price=producto.Price,
// ProductBrand=producto.ProductBrand.Name,
// ProductType=producto.ProductType.Name
//};
//Si no encontramos productos 404= error notfound
if (producto == null)
{
return(NotFound(new ApiResponse(404)));
}
return(_mapper.Map <Product, ProductToReturnDto>(producto));
}
public async Task <IReadOnlyList <Product> > GetProductsAsync(ProductSpecParams productParams)
{
var spec = new ProductWithTypesAndBrandsSpecification(productParams);
return((await _productStorage.ListAsync(spec))
.Select(p => p.ToCoreEntity())
.ToList());
}
public async Task <Product> GetProductAsync(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
ProductDto productDto = await _productStorage.GetEntityWithSpec(spec);
return(productDto?.ToCoreEntity());
}
public async Task <ActionResult <IReadOnlyList <Product> > > GetProducts()
{
var spec = new ProductWithTypesAndBrandsSpecification();
var products = await _productRepo.ListAllWithSpec(spec);
return(Ok(_mapper
.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products)));
}
public async Task <ActionResult <ProductToReturnDto> > GetProduct(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);
if (product == null)
{
return(NotFound(new ApiResponse(404)));
}
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProducts(
[FromQuery] ProductSpecParams productParams)
{
//From Query để có thể match request với các giá trị trong object productParams
var spec = new ProductWithTypesAndBrandsSpecification(productParams);
var countSpec = new ProductWithFIltersForCountSpecification(productParams);
var totalItem = await _unitOfWork.Repository <Product>().CountAsync(countSpec);
var products = await _unitOfWork.Repository <Product>().ListAsync(spec);
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex, productParams.PageSize, totalItem, data)));
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProducts(
[FromQuery] ProductSpecParams param)
{
var spec = new ProductWithTypesAndBrandsSpecification(param);
var countSpec = new ProductWithTypesAndBrandsCountSpecification(param);
var count = await _prodcutRepo.CountAsync(countSpec);
var products = await _prodcutRepo.ListAsync(spec);
var productRto = _mapper.Map <IReadOnlyCollection <Product>, IReadOnlyCollection <ProductToReturnDto> >(products);
var res = new Pagination <ProductToReturnDto>(param.PageIndex, param.PageSize, count, (IReadOnlyList <ProductToReturnDto>)productRto);
return(Ok(res));
}
public async Task <ActionResult <Pagination <ProductToReturnDTO> > > GetProducts(
[FromQuery] ProductSpecParams productParams)
{
var spec = new ProductWithTypesAndBrandsSpecification(productParams);
var products = await _productsRepo.ListOnlyAsync(spec);
var countSpec = new ProductWithFiltersForCountSpecification(productParams);
var totalItem = await _productsRepo.CountAsync(countSpec);
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDTO> >(products);
//entity framework core
return(Ok(new Pagination <ProductToReturnDTO>(productParams.PageIndex, productParams.PageSize,
totalItem, data)));
}
public async Task <ActionResult <ProductToReturnDTO> > GetProduct(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
//dont want the request to wait around if it could be doing other things, passes
//the request to av delegate
//the request the thread is running on can go handle other things
var product = await _productsRepo.GetEntityWithSpec(spec);
if (product == null)
{
return(NotFound(new ApiResponse(404)));
}
return(_mapper.Map <Product, ProductToReturnDTO>(product));
//takes the first one in and converts it to the second one
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetProducts([FromQuery] ProductSpecParams productParams)
{
var spec = new ProductWithTypesAndBrandsSpecification(productParams);
var countSpec = new ProductWithFiltersForCountSpecification(productParams);
var totalItems = await _productsRepo.CountAsync(countSpec);
var products = await _productsRepo.ListAsync(spec);
if (products == null)
{
return(NotFound(new ApiResponse(404)));
}
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
return(Ok(new Pagination <ProductToReturnDto>(productParams.PageIndex, productParams.PageSize, totalItems, data)));
}
public async Task <Order> CreateOrderAdminAsync(string buyerEmail, int deliveryMethodId, List <BasketItem> orderItems, Address shippingAddress)
{
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethod>().GetByIdAsync(deliveryMethodId);
var items = new List <OrderItem>();
foreach (var item in orderItems)
{
var specProduct = new ProductWithTypesAndBrandsSpecification(item.Id);
var productItem = await _unitOfWork.Repository <Product>().GetEntityWithSpec(specProduct);
var itemOrdered = new ProductItemOrdered(productItem.Id, item.Size, productItem.Name,
productItem.Photos.FirstOrDefault(x => x.IsMain)?.PictureUrl);
var productSize = productItem.ProductSizes.FirstOrDefault(x => x.Size == item.Size);
var orderItem = new OrderItem();
if (item.Quantity > productSize.Quantity)
{
orderItem = new OrderItem(itemOrdered, productItem.Price, productSize.Quantity);
productSize.Quantity = 0;
}
else
{
orderItem = new OrderItem(itemOrdered, productItem.Price, item.Quantity);
productSize.Quantity = productSize.Quantity - item.Quantity;
}
productItem.AddOrUpdateProductSize(productSize.Size, productSize.Quantity);
_unitOfWork.Repository <Product>().Update(productItem);
items.Add(orderItem);
}
var subtotal = items.Sum(item => item.Price * item.Quantity);
var order = new Order(items, buyerEmail, shippingAddress, deliveryMethod, subtotal);
order.Status = OrderStatus.PaymentRecevied;
_unitOfWork.Repository <Order>().Add(order);
var result = await _unitOfWork.Complete();
//return order
return(order);
}
public async Task <ActionResult <Product> > CreateOrUpdateProductSize(ProductSizeToCreateDto productSizeToCreate)
{
var spec = new ProductWithTypesAndBrandsSpecification(productSizeToCreate.ProductId);
var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);
if (productSizeToCreate != null)
{
product.AddOrUpdateProductSize(productSizeToCreate.Size, productSizeToCreate.Quantity);
_unitOfWork.Repository <Product>().Update(product);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem creating product")));
}
}
var productSize = product.ProductSizes.FirstOrDefault(x => x.Size == productSizeToCreate.Size);
return(Ok(_mapper.Map <ProductSize, WarehouseToReturnDto>(productSize)));
}
public async Task <ActionResult <ProductToReturnDto> > GetProduct(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
//return await _productRepo.GetByIdAsync(id);
var product = await _productRepo.GetEntityWithSpec(spec);
if (product == null)
{
return(NotFound(new ApiResponse(404)));
}
// return new ProductToReturnDto
// {
// Id= product.Id,
// Name = product.Name,
// Description = product.Description,
// PicturesUrl = product.PicturesUrl,
// Price = product.Price,
// ProducBrand = product.ProducBrand.Name,
// ProductType = product.ProductType.Name
// };
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <ActionResult <ProductToReturnDTO> > GetProduct(int id)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _productRepo.GetEntityWithSpec(spec);
if (product == null)
{
return(NotFound(new ApiResponse(404)));
}
return(_mapper.Map <Product, ProductToReturnDTO>(product));
/* new ProductToReturnDTO{
* Id = product.Id,
* Name = product.Name,
* Description = product.Description,
* Price = product.Price,
* PictureUrl = product.PictureUrl,
* ProductBrand = product.ProductBrand.Name,
* ProductType = product.ProductType.Name
*
* }; */
}
public async Task <ActionResult <ProductToReturnDto> > SetMainPhoto(int id, int photoId)
{
var spec = new ProductWithTypesAndBrandsSpecification(id);
var product = await _unitOfWork.Repository <Product>().GetEntityWithSpec(spec);
if (product.Photos.All(x => x.Id != photoId))
{
return(NotFound());
}
product.SetMainPhoto(photoId);
_unitOfWork.Repository <Product>().Update(product);
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem adding photo product")));
}
return(_mapper.Map <Product, ProductToReturnDto>(product));
}
public async Task <Order> CreateOrderAsync(string buyerEmail, int deliveryMethodId, string basketId, Address shippingAddress)
{
//get bastket from the repo
var basket = await _basketRepo.GetBasketAsync(basketId);
//get items from the product repo
var items = new List <OrderItem>();
foreach (var item in basket.Items)
{
var specProduct = new ProductWithTypesAndBrandsSpecification(item.Id);
var productItem = await _unitOfWork.Repository <Product>().GetEntityWithSpec(specProduct);
var itemOrdered = new ProductItemOrdered(productItem.Id, item.Size, productItem.Name,
productItem.Photos.FirstOrDefault(x => x.IsMain)?.PictureUrl);
var productSize = productItem.ProductSizes.FirstOrDefault(x => x.Size == item.Size);
var orderItem = new OrderItem();
if (item.Quantity > productSize.Quantity)
{
orderItem = new OrderItem(itemOrdered, productItem.Price, productSize.Quantity);
productSize.Quantity = 0;
}
else
{
orderItem = new OrderItem(itemOrdered, productItem.Price, item.Quantity);
productSize.Quantity = productSize.Quantity - item.Quantity;
}
productItem.AddOrUpdateProductSize(productSize.Size, productSize.Quantity);
_unitOfWork.Repository <Product>().Update(productItem);
items.Add(orderItem);
}
//get delivery method from repo
var deliveryMethod = await _unitOfWork.Repository <DeliveryMethod>().GetByIdAsync(deliveryMethodId);
//calc subtotal
var subtotal = items.Sum(item => item.Price * item.Quantity);
//check to see if order exists
var spec = new OrderByPaymentIntentIdWithItemsSpecification(basket.PaymentIntentId);
var existingOrder = await _unitOfWork.Repository <Order>().GetEntityWithSpec(spec);
if (existingOrder != null)
{
_unitOfWork.Repository <Order>().Delete(existingOrder);
await _paymentService.CreateOrUpdatePaymentIntent(basket.PaymentIntentId);
}
//create order
var order = new Order(items, buyerEmail, shippingAddress, deliveryMethod, subtotal, basket.PaymentIntentId);
_unitOfWork.Repository <Order>().Add(order);
//save to db
var result = await _unitOfWork.Complete();
if (result <= 0)
{
return(null);
}
//return order
return(order);
}
