public async Task <OperationResult> DeleteImageAsync(DeleteProductImageInput input)
{
var validateResult = await _productImageValidator.ValidateDeleteProductImage(input);
if (validateResult.IsSuccess)
{
var productDtoResult = await _productService.GetAsync(input.ProductId);
if (!productDtoResult.IsSuccess)
{
return(OperationResultEnumerable <ProductImageDto> .Fail(productDtoResult.Validations));
}
var images = await _repository.GetProductImages(productDtoResult.Result.ConvertToEntity());
images = images.Where(x => x.Id != input.ProductImageId);
await _repository.UpdateProductImages(images);
return(OperationResult.Success());
}
else
{
return(OperationResult.Fail(validateResult));
}
}
public async Task <OperationResultEnumerable <AddressDto> > GetAllAsync(string customerEmail)
{
var addresses = await _addressRepository.GetByCustomerAsync(customerEmail);
if (addresses is null)
{
return(OperationResultEnumerable <AddressDto> .NotFound());
}
return(OperationResultEnumerable <AddressDto> .Success(addresses.Addresses.Select(x => x.ConvertToDto())));
}
public async Task <OperationResultEnumerable <ProductImageDto> > GetAllImageAsync(string productId)
{
var productDtoResult = await _productService.GetAsync(productId);
if (!productDtoResult.IsSuccess)
{
return(OperationResultEnumerable <ProductImageDto> .Fail(productDtoResult.Validations));
}
var images = await _repository.GetProductImages(productDtoResult.Result.ConvertToEntity());
return(OperationResultEnumerable <ProductImageDto> .Success(images.Select(x => x.ConvertToDto())));
}
public async Task <OperationResultEnumerable <ProductVariantDto> > UpdateAsync(UpdateProductVariantInput input)
{
var validationResult = await _productVariantValidator.ValidateUpdateProductVariant(input);
if (validationResult.IsSuccess)
{
var taskGetVariants = _productVariantRepository.GetByProduct(new() { Id = input.ProductId });
foreach (var variant in input.Variants)
{
var entity = await _productVariantRepository.GetByNameAsync(new() { Id = input.ProductId }, variant.Name);
if (entity is null)
{
await _productVariantRepository.CreateAsync(new()
{
Name = variant.Name,
ProductId = input.ProductId,
Values = variant.Values
});
}
else
{
await _productVariantRepository.UpdateAsync(new()
{
Id = entity.Id,
Name = variant.Name,
ProductId = input.ProductId,
Values = variant.Values
});
}
}
var variants = await taskGetVariants;
var variantsToDelete = variants.Where(x => !input.Variants.Select(y => y.Name).Contains(x.Name));
foreach (var item in variantsToDelete)
{
await _productVariantRepository.RemoveAsync(item);
}
variants = await _productVariantRepository.GetByProduct(new() { Id = input.ProductId });
return(OperationResultEnumerable <ProductVariantDto> .Success(variants.Select(x => x.ConvertToDto())));
}
return(OperationResultEnumerable <ProductVariantDto> .Fail(validationResult));
}
public async Task <OperationResultEnumerable <ProductCategoryDto> > GetAllAsync()
{
var categories = await _productCategoryRepository.GetAllAsync();
List <ProductCategoryDto> categoryDtos = new();
foreach (var item in categories)
{
var productCount = await _productRepository.CountByCategory(item.Name);
categoryDtos.Add(item.ConvertToDto(productCount));
}
return(OperationResultEnumerable <ProductCategoryDto> .Success(categoryDtos));
}
public async Task <OperationResultEnumerable <ProductSubCategoryDto> > GetSubCategories(string categoryName)
{
var entity = await _productCategoryRepository.GetByNameAsync(categoryName);
List <ProductSubCategoryDto> subcategories = new();
foreach (var item in entity.SubCategories)
{
var productCount = await _productRepository.CountBySubCategory(categoryName, item);
subcategories.Add(new(categoryName, item, productCount));
}
return(OperationResultEnumerable <ProductSubCategoryDto> .Success(subcategories));
}
public OperationResultEnumerable <ProductDto> GetByCategory(string category, string subcategory)
{
return(OperationResultEnumerable <ProductDto> .Success(_repository.GetAllProductsByCategory(category, subcategory).Select(x => x.ConvertToDto())));
}
public async Task <OperationResultEnumerable <ProductDto> > GetAllAsync()
{
IEnumerable <Product> products = await _repository.GetAllAsync();
return(OperationResultEnumerable <ProductDto> .Success(products.Select(x => x.ConvertToDto())));
}
public async Task <OperationResultEnumerable <ProductVariantDto> > GetAllAsync(string productId)
{
var entity = await _productVariantRepository.GetByProduct(new() { Id = productId });
return(OperationResultEnumerable <ProductVariantDto> .Success(entity.Select(x => x.ConvertToDto())));
}
public async Task <OperationResultEnumerable <CouponCodeDto> > GetCouponCodeAsync()
{
var couponCodes = await _couponCodeRepository.GetAllAsync();
return(OperationResultEnumerable <CouponCodeDto> .Success(couponCodes.Select(x => x.ConvertToDto())));
}
public async Task <OperationResultEnumerable <CustomerDto> > GetAllAsync()
{
var customers = await _customerRepository.GetAllAsync();
return(OperationResultEnumerable <CustomerDto> .Success(customers.Select(x => x.ConvertToDto())));
}
