public async Task <ActionResult <SearchResultsVM> > Search(string query, uint page)
{
ProductsListDTO productsListDto = await _catalogManager.SearchByNameOrDescription(new CatalogSearchDTO
{
Page = page,
PageSize = PageSize,
NameOrDescription = query
});
return(View(new SearchResultsVM
{
Products = productsListDto.Products.Select(p => new ProductShortVM
{
Id = p.Id,
Brand = p.Brand?.Name,
Country = p.Country?.Name,
Image = p.Image,
Name = p.Name,
Price = p.Price,
Weight = p.Weight
}),
PagingInfo = new PagingInfoVM
{
CurrentPage = productsListDto.PagingInfo.CurrentPage,
TotalItems = productsListDto.PagingInfo.TotalItems,
ItemsPerPage = productsListDto.PagingInfo.ItemsPerPage
}
}));
}
public ProductsListDTO GetAll(int page)
{
var productsList = new ProductsListDTO();
var products = _productRepository.GetAll()
.Include(p => p.Category);
productsList.Products = _mapper.Map <IEnumerable <ProductDTO> >(products.Skip((page - 1) * 10).Take(10));
productsList.ProductsCount = products.Count();
return(productsList);
}
public async Task UpdateProductsAsync([FromBody] ProductsListDTO productsList)
{
try
{
await _productService.UpdateProductsAsync(productsList);
}
catch (Exception exception)
{
#region Write To Log (Severity: Error)
_logger.LogError(ELogEvents.FailedToUpdateProducts.ToEventID(),
exception,
"Failed to update products");
#endregion
}
}
public ProductsListViewModel(ProductsListDTO serviceDto)
{
this.Products = serviceDto.Products.Select(dto => new ProductViewModel()
{
Category = dto.Category,
Description = dto.Description,
Name = dto.Name,
Price = dto.Price,
Id = dto.Id
});
this.PagingInfo = new PagingInfo()
{
CurrentPage = serviceDto.PagingInfo.CurrentPage,
ItemsPerPage = serviceDto.PagingInfo.ItemsPerPage,
TotalItems = serviceDto.PagingInfo.TotalItems
};
this.CurrentCategory = serviceDto.CurrentCategory;
}
public async Task <ProductsListDTO> GetAllProducts(string category, int productPage = 1)
{
var repoQuery =
await this._productRepository
.Products
.Where(c => category == null || c.Category == category)
.OrderBy(p => p.Id)
.Skip((productPage - 1) * PageSize)
.Take(PageSize)
.ToListAsync();
var serviceModel = new ProductsListDTO()
{
Products = repoQuery.Select(q => new ProductDTO()
{
Category = q.Category,
Description = q.Description,
Name = q.Name,
Price = q.Price,
Id = q.Id
}),
PagingInfo = new PagingInfoDTO()
{
TotalItems = category == null ?
await this._productRepository
.Products
.CountAsync()
:
await this._productRepository
.Products
.Where(pc => pc.Category == category)
.CountAsync(),
CurrentPage = productPage,
ItemsPerPage = this.PageSize
},
CurrentCategory = category
};
return(serviceModel);
}
public async Task <ProductsListDTO> Products(ProductsFiltersDTO filters)
{
IQueryable <Product> products = Database.Products;
if (filters == null)
{
return(new ProductsListDTO
{
PagingInfo = new PagingInfoDTO
{
CurrentPage = 1,
ItemsPerPage = 15,
TotalItems = await products.CountAsync()
},
// Скипаем ноль объектов, и берем 15.
Products = await MapToDto(0, 15)
});
}
if (filters.Page < 1)
{
filters.Page = 1;
}
if (filters.PageSize < 1)
{
filters.PageSize = 1;
}
if (filters.Removed == RemoveState.Yes)
{
products = products.Where(p => p.Removed);
}
else if (filters.Removed == RemoveState.No)
{
products = products.Where(p => p.Removed == false);
}
if (!string.IsNullOrWhiteSpace(filters.Category))
{
products = products.Where(p => p.Category.Name.Contains(filters.Category));
}
if (!string.IsNullOrWhiteSpace(filters.Brand))
{
products = products.Where(p => p.Brand.Name.Contains(filters.Brand));
}
if (!string.IsNullOrWhiteSpace(filters.Country))
{
products = products.Where(p => p.Country.Name.Contains(filters.Country));
}
if (!string.IsNullOrWhiteSpace(filters.Name))
{
products = products.Where(p => p.Name.Contains(filters.Name));
}
if (filters.Price.HasValue)
{
products = products.Where(p => p.Price == filters.Price);
}
if (filters.Weight.HasValue)
{
products = products.Where(p => p.Weight == filters.Weight);
}
int totalItems = await products.CountAsync();
int skipCount = (int)(filters.Page - 1) * filters.PageSize;
var productsManagmentList = new ProductsListDTO
{
Products = await MapToDto(skipCount, filters.PageSize),
PagingInfo = new PagingInfoDTO
{
CurrentPage = (int)filters.Page,
ItemsPerPage = filters.PageSize,
TotalItems = totalItems
}
};
return(productsManagmentList);
#region Local Functions
async Task <IEnumerable <ProductDTO> > MapToDto(int skip, int pageSize)
{
var dtoList = await products.Select(p => new ProductDTO
{
Id = p.Id,
Name = p.Name,
BrandId = p.BrandId,
CategoryId = p.CategoryId,
CountryId = p.CountryId,
Character = p.Character,
Description = p.Description,
Image = p.Image,
Price = p.Price,
Weight = p.Weight,
Removed = p.Removed,
Brand = p.Brand == null ? null : new BrandDTO
{
Id = p.Brand.Id,
Name = p.Brand.Name
},
Category = p.Category == null ? null : new CategoryDTO
{
Id = p.Category.Id,
Name = p.Category.Name
},
Country = p.Country == null ? null : new CountryDTO
{
Id = p.Country.Id,
Name = p.Country.Name
}
}).OrderBy(p => p.Id).Skip(skip).Take(pageSize).ToArrayAsync();
return(dtoList);
}
#endregion
}
/// <summary>
/// Update/Insert product
/// </summary>
/// <param name="productsList">The product to upsert</param>
/// <returns>Update result of upsert operation</returns>
/// <exception cref="ArgumentNullException">Throws when product is null</exception>
/// <exception cref="ArgumentException">Throws when invalid chain</exception>
/// <exception cref="ArgumentException">Throws when store id is empty</exception>
/// <exception cref="ArgumentException">Throws when products are empty</exception>
public async Task UpdateProductsAsync(ProductsListDTO productsList)
{
#region Validations
if (productsList is null)
{
throw new ArgumentNullException(nameof(productsList));
}
if (productsList.ChainID == EChain.None)
{
throw new ArgumentException("Invalid chain", nameof(productsList.ChainID));
}
if (string.IsNullOrWhiteSpace(productsList.StoreID))
{
throw new ArgumentException("Store id is empty", nameof(productsList.StoreID));
}
if (productsList.Products.IsNullOrEmpty())
{
throw new ArgumentException("Products are empty", nameof(productsList.Products));
}
#endregion
#region Upsert Products
var productModels = new List <Product>(productsList.Products.Count());
foreach (var product in productsList.Products)
{
decimal.TryParse(product.Quantity, out decimal quantity);
decimal.TryParse(product.UnitOfMeasurePrice, out decimal unitOfMeasurePrice);
await _productRepository.UpsertProductAsync(new Product
{
Code = product.ItemCode,
Name = product.ItemName,
ManufacturerName = product.ManufacturerName,
ManufactureCountry = product.ManufactureCountry,
ManufacturerDescription = product.ManufacturerItemDescription,
Quantity = quantity,
UnitQuantityType = product.UnitQty.ToUnitQuantity(),
UnitOfMeasure = ExtractUnitOfMeasure(product.UnitOfMeasure),
UnitOfMeasurePrice = unitOfMeasurePrice
});
}
#endregion
#region Insert Product Prices
await _productPricesRepository.InsertProductsPricesProductAsync(productsList.Products.Select(product =>
new ProductPrice
{
Code = product.ItemCode,
ChainID = productsList.ChainID,
StoreID = Convert.ToInt32(productsList.StoreID),
Price = Convert.ToDecimal(product.ItemPrice),
PriceUpdateDate = product.PriceUpdateDate
}));
#endregion
}
