string GetCellValue(Specification specification, ItemSpecification itemSpecification)
{
if (itemSpecification == null)
{
return("NC");
}
string value = "";
switch (specification.Type)
{
case SpecificationType.Boolean:
value = itemSpecification.BooleanValue.ToString();
break;
case SpecificationType.Interger:
value = itemSpecification.IntegerValue.ToString();
break;
case SpecificationType.String:
value = itemSpecification.StringValue.ToString();
break;
case SpecificationType.Decimal:
value = itemSpecification.DecimalValue.ToString();
break;
}
value += " " + specification.Unity;
return(value);
}
public void ItemSpecification_Bad_Id_Test()
{
var spec = new ItemSpecification(new List <int>()
{
1000
});
var result = _evaluator.GetQuery(GetItems().AsQueryable(), spec).Any();
Assert.False(result);
}
public void ItemSpecification_Test()
{
var spec = new ItemSpecification(new List <int>()
{
_itemId
});
var result = _evaluator.GetQuery(GetItems().AsQueryable(), spec).FirstOrDefault();
Assert.NotNull(result);
Assert.Equal(_itemId, result.Id);
}
private async Task <IEnumerable <BasketItemsModel> > GetBasketItems(Basket basket)
{
var itemSpec = new ItemSpecification(basket.BasketItems.Select(x => x.ItemId));
var items = await _itemRepository.ListAsync(itemSpec);
return(basket.BasketItems.Select(x => new BasketItemsModel()
{
ItemId = x.ItemId,
Price = x.Price,
Quantity = x.Quantity,
Title = items.First().Title
}));
}
public void UpdateItemInfos(Item item, string itemInfosData)
{
if (itemInfosData == null)
{
itemInfosData = "";
}
var currentItemInfos = _context.ItemSpecifications.Where(ii => ii.ItemId == item.Id).ToList();
_context.ItemSpecifications.RemoveRange(currentItemInfos);
var itemInfoTypes = _context.Specifications.ToList();
var itemInfoData = itemInfosData.Split('\n');
foreach (var itemInfoSplited in itemInfoData)
{
var intemInfoType = itemInfoTypes.SingleOrDefault(iit => iit.Name == itemInfoSplited.Split(':')[0]);
if (intemInfoType == null)
{
continue;
}
var itemInfo = new ItemSpecification();
itemInfo.ItemId = item.Id;
itemInfo.SpecificationId = intemInfoType.Id;
string value = itemInfoSplited.Split(':')[1];
switch (intemInfoType.Type)
{
case SpecificationType.Boolean:
itemInfo.BooleanValue = bool.Parse(value);
break;
case SpecificationType.Interger:
itemInfo.IntegerValue = int.Parse(value);
break;
case SpecificationType.String:
itemInfo.StringValue = value;
break;
case SpecificationType.Decimal:
itemInfo.DecimalValue = decimal.Parse(value);
break;
}
_context.ItemSpecifications.Add(itemInfo);
}
_context.SaveChanges();
}
public IActionResult Index(ItemSpecification specification, ItemBrowserViewModel model = null)
{
if (specification?.PageNumber != null)
{
specification.PageNumber -= 1;
}
if (model == null)
{
return(View(new ItemBrowserViewModel(this.itemService.GetAllItems(specification))));
}
else
{
return(View(new ItemBrowserViewModel(this.itemService.GetAllItems(specification))
{
SelectedCategory = model.SelectedCategory
}));
}
}
public async Task CreateOrderAsync(int basketId, string comment, string address)
{
var basketSpec = new BasketWithItemsSpecification(basketId);
var basket = await _basketRepository.FirstOrDefaultAsync(basketSpec);
var itemSpec = new ItemSpecification(basket.BasketItems.Select(x => x.ItemId));
var items = await _itemRepository.ListAsync(itemSpec);
List <OrderItem> itemsToOrder = basket.BasketItems.Select(x => {
var item = items.First(i => x.ItemId == i.Id);
var orderItem = new OrderItem(new OrderItemOrdered(item.Id, item.Title), x.Price, x.Quantity);
return(orderItem);
}).ToList();
await _basketRepository.DeleteAsync(basket);
Order order = new Order(basket.UserId, address, comment, itemsToOrder);
_ = await _orderRepository.AddAsync(order);
}
public PagedResult <ItemHeader> GetAllItems(ItemSpecification specification = null)
{
if (specification == null)
{
specification = new ItemSpecification();
}
if (specification.PageSize < 0)
{
specification.PageSize = null;
}
if (specification.PageNumber < 0)
{
specification.PageNumber = null;
}
IQueryable <Item> query = this.context.Items
.Include(x => x.Ratings);
if (!string.IsNullOrWhiteSpace(specification.ComplexFilter))
{
query = query.Where(x => x.Name.Contains(specification.ComplexFilter) ||
x.Manufacturer.Contains(specification.ComplexFilter) ||
x.ShortDescription.Contains(specification.ComplexFilter));
}
if (!string.IsNullOrWhiteSpace(specification.Name))
{
query = query.Where(x => x.Name.Contains(specification.Name));
}
if (specification.SelectedCategories.Any())
{
var selectedCategoriesEnum = new List <Category>();
specification.SelectedCategories.ForEach(x =>
{
selectedCategoriesEnum.Add(EnumExtensionMethods.GetValueFromDescription <Category>(x));
});
query = query.Where(x => selectedCategoriesEnum.Contains(x.Category));
}
if (specification.SelectedManufacturers.Any())
{
query = query.Where(x => specification.SelectedManufacturers.Contains(x.Manufacturer));
}
if (specification.HasRGB.HasValue)
{
query = query.Where(x => x.HasRGB == specification.HasRGB);
}
if (specification.IsNewArrival.HasValue)
{
query = query.Where(x => x.DateSinceInStore > DateTime.Now.AddDays(-30));
}
if (specification.IsDiscounted.HasValue)
{
query = query.Where(x => x.DiscountedPrice != null && x.DiscountedPrice < x.OriginalPrice);
}
if (specification.IsGaming.HasValue)
{
query = query.Where(x => x.GamingFlag == specification.IsGaming);
}
if (specification.IsUsed.HasValue)
{
query = query.Where(x => x.IsUsed == specification.IsUsed);
}
if (specification.MinPrice != null)
{
query = query.Where(x => (x.DiscountedPrice ?? x.OriginalPrice) >= specification.MinPrice);
}
if (specification.MaxPrice != null)
{
query = query.Where(x => (x.DiscountedPrice ?? x.OriginalPrice) <= specification.MaxPrice);
}
if (specification.MinRating != null)
{
query = query.Where(x => (x.Ratings.Any() ? Convert.ToInt32(x.Ratings.Average(y => y.Value)) : 0) >= specification.MinRating);
}
if (specification.MaxRating != null)
{
query = query.Where(x => (x.Ratings.Any() ? Convert.ToInt32(x.Ratings.Average(y => y.Value)) : 0) <= specification.MaxRating);
}
//order
switch (specification.Order)
{
case ItemSpecification.ItemOrder.PriceAscending:
query = query.OrderBy(x => x.DiscountedPrice ?? x.OriginalPrice);
break;
case ItemSpecification.ItemOrder.PriceDescending:
query = query.OrderByDescending(x => x.DiscountedPrice ?? x.OriginalPrice);
break;
case ItemSpecification.ItemOrder.RatingAscending:
query = query.OrderBy(x => (x.Ratings.Any() ? Convert.ToInt32(x.Ratings.Average(y => y.Value)) : 0));
break;
case ItemSpecification.ItemOrder.RatingDescending:
query = query.OrderByDescending(x => (x.Ratings.Any() ? Convert.ToInt32(x.Ratings.Average(y => y.Value)) : 0));
break;
}
int?allResultsCount = null;
if ((specification.PageSize ?? 0) != 0)
{
specification.PageNumber ??= 0;
allResultsCount = query.Count();
query = query
.Skip(specification.PageNumber.Value * specification.PageSize.Value)
.Take(specification.PageSize.Value);
}
int totalMaxPrice, totalMinPrice;
var maxDiscounted = context.Items.Max(x => x.DiscountedPrice);
var maxOriginal = context.Items.Max(x => x.OriginalPrice);
var minDiscounted = context.Items.Min(x => x.DiscountedPrice);
var minOriginal = context.Items.Min(x => x.OriginalPrice);
if (maxDiscounted != null)
{
totalMaxPrice = maxOriginal > maxDiscounted ? maxOriginal : maxDiscounted.Value;
totalMinPrice = maxOriginal > maxDiscounted ? minOriginal : minDiscounted.Value;
}
else
{
totalMaxPrice = maxOriginal;
totalMinPrice = minOriginal;
}
return(new PagedResult <ItemHeader>
{
AllResultsCount = allResultsCount,
Results = query.ToList().Select(ItemHeaderSelectorFunc.Value),
Categories = context.Items.Select(x => EnumExtensionMethods.GetDescription(x.Category)).Distinct().ToList(),
Manufacturers = context.Items.Select(x => x.Manufacturer).Distinct().ToList(),
TotalMaxPrice = totalMaxPrice,
TotalMinPrice = totalMinPrice,
PageNumber = specification.PageNumber,
PageSize = specification.PageSize,
Specification = specification,
});
}
