public void Update(ProductVariant productVariant)
{
var count =
GetBaseQuery(productVariant).Cacheable().RowCount();
var total =
GetBaseQuery(productVariant)
.Select(Projections.Sum<ProductReview>(x => x.Rating))
.Cacheable()
.SingleOrDefault<int>();
if (count == 0)
{
productVariant.NumberOfReviews = 0;
productVariant.Rating = 0;
}
else
{
productVariant.NumberOfReviews = count;
var rating = (decimal) total/count;
productVariant.Rating = (Math.Round((rating * 2), MidpointRounding.AwayFromZero) / 2);
}
_session.Transact(session => session.Update(productVariant));
}
public IEnumerable<PriceBreak> ImportVariantPriceBreaks(ProductVariantImportDataTransferObject dto, ProductVariant productVariant)
{
var priceBreaksToAdd = dto.PriceBreaks.Where(s => !productVariant.PriceBreaks.Select(@break => @break.Quantity).Contains(s.Key)).ToList();
var priceBreaksToRemove = productVariant.PriceBreaks.Where(@break => !dto.PriceBreaks.Keys.Contains(@break.Quantity)).ToList();
var priceBreaksToUpdate = productVariant.PriceBreaks.Where(@break => !priceBreaksToRemove.Contains(@break)).ToList();
foreach (var item in priceBreaksToAdd)
{
var priceBreak = new PriceBreak
{
Quantity = item.Key,
Price = item.Value,
ProductVariant = productVariant
};
productVariant.PriceBreaks.Add(priceBreak);
}
foreach (var priceBreak in priceBreaksToRemove)
{
productVariant.PriceBreaks.Remove(priceBreak);
_session.Delete(priceBreak);
}
foreach (var priceBreak in priceBreaksToUpdate)
priceBreak.Price = dto.PriceBreaks[priceBreak.Quantity];
return productVariant.PriceBreaks;
}
public bool IsInWishlist(ProductVariant productVariant)
{
var myWishlist = GetMyWishlist();
if (myWishlist == null)
return false;
return myWishlist.WishlistItems.Any(item => item.Item == productVariant);
}
public int GetRequestedQuantity(ProductVariant productVariant, int additionalQuantity)
{
var requestedQuantity = additionalQuantity;
var existingItem = _cart.Items.FirstOrDefault(item => item.Item == productVariant);
if (existingItem != null)
requestedQuantity += existingItem.Quantity;
return requestedQuantity;
}
public void Product_Availability_IfPublishDateSetButInTheFutureShouldBePreOrder()
{
var product = new ProductVariant { AvailableOn = DateTime.Today.AddDays(1) };
var availabilityStatus = product.Availability;
availabilityStatus.Should().Be(ProductAvailability.PreOrder);
}
public void Add_ShouldPersistToTheSession()
{
var product = new Product();
var productVariant = new ProductVariant {Product = product};
_service.Add(productVariant);
Session.QueryOver<ProductVariant>().RowCount().Should().Be(1);
}
public void Add_ShouldAddVariantToTheProductsVariants()
{
var product = new Product();
var productVariant = new ProductVariant {Product = product};
_service.Add(productVariant);
product.Variants.Should().Contain(productVariant);
}
public bool CanShip(ProductVariant productVariant)
{
if (!productVariant.HasRestrictedShipping)
return true;
return _cartModel.PotentiallyAvailableShippingMethods.Any(
method =>
productVariant.RestrictedTo.Contains(method.GetType().FullName, StringComparer.OrdinalIgnoreCase));
}
public void Product_Availability_IfPublishDateSetButInThePastShouldBeAvailable()
{
var product = new ProductVariant { AvailableOn = DateTime.Today.AddDays(-1) };
var availabilityStatus = product.Availability;
availabilityStatus.Should().Be(ProductAvailability.Available);
}
public void Delete_ShouldDeleteFromSession()
{
var productVariant = new ProductVariant();
Session.Transact(session => session.Save(productVariant));
_service.Delete(productVariant);
Session.QueryOver<ProductVariant>().RowCount().Should().Be(0);
}
public void ProductVariant_Price_WithNoTaxRateShouldBePricePreTax()
{
var variant = new ProductVariant {BasePrice = 1};
decimal price = variant.Price;
price.Should().Be(1);
}
public void ProductVariant_ReducedByPercentage_ShouldReturnZeroIfPreviousPriceIsNull()
{
var variant = new ProductVariant {BasePrice = 1};
decimal reducedByPercentage = variant.ReducedByPercentage;
reducedByPercentage.Should().Be(0);
}
public void ProductVariant_ReducedByPercentage_ShouldBeTheReducedByAsAPercentageOfThePreviousPrice()
{
var variant = new ProductVariant {BasePrice = 1, PreviousPrice = 2};
decimal reducedByPercentage = variant.ReducedByPercentage;
reducedByPercentage.Should().Be(0.5m);
}
public void ProductVariant_ReducedBy_ShouldBeZeroIfPriceIsGreaterThanPreviousPrice()
{
var variant = new ProductVariant {BasePrice = 2, PreviousPrice = 1};
decimal reducedPrice = variant.ReducedBy;
reducedPrice.Should().Be(0);
}
public void ProductVariant_ReducedBy_ShouldBeTheDifferenceIfThePreviousPriceIsGreaterThanThePrice()
{
var variant = new ProductVariant {BasePrice = 1, PreviousPrice = 2};
decimal reducedPrice = variant.ReducedBy;
reducedPrice.Should().Be(1);
}
public void Product_Availability_IfPublishDateNotSetShouldBeOnPreOrder()
{
var variant = new ProductVariant();
var availabilityStatus = variant.Availability;
availabilityStatus.Should().Be(ProductAvailability.PreOrder);
}
public void ProductVariant_ReducedBy_IsZeroIfPreviousPriceIsNotSet()
{
var variant = new ProductVariant {BasePrice = 1, PreviousPrice = null};
decimal reducedPrice = variant.ReducedBy;
reducedPrice.Should().Be(0);
}
public void Remove(ProductVariant productVariant)
{
var warehouseStocks = _session.QueryOver<WarehouseStock>().Where(stock => stock.ProductVariant.Id == productVariant.Id).List();
if (warehouseStocks.Any())
{
_session.Transact(session => warehouseStocks.ForEach(session.Delete));
}
}
public void SetViewData(ViewDataDictionary viewData, ProductVariant productVariant)
{
viewData["gift-card-type-options"] = _getGiftCardTypeOptions.Get();
viewData["product-variant-type-options"] = _getProductVariantTypeOptions.Get();
viewData["tax-rate-options"] = _getTaxRateOptions.GetOptions();
viewData["tracking-policy"] = _getTrackingPolicyOptions.Get();
viewData["shipping-options"] = _getShippingOptions.Get(productVariant);
viewData["e-tag-options"] = _eTagAdminService.GetOptions();
}
public void Remove(ProductVariant productVariant)
{
var wishlist = GetMyWishlist(true);
var wishlistItem = wishlist.WishlistItems.SingleOrDefault(item => item.Item == productVariant);
if (wishlistItem != null)
{
wishlist.WishlistItems.Remove(wishlistItem);
_session.Transact(session => session.Delete(wishlistItem));
}
}
public void Edit_ShouldUpdateAVariant()
{
var productVariant = new ProductVariant();
Session.Transact(session => session.Save(productVariant));
productVariant.SKU = "updated";
_service.Update(productVariant);
Session.Evict(productVariant);
Session.Get<ProductVariant>(1).SKU.Should().Be("updated");
}
public void Generate(ProductVariant productVariant)
{
var warehouses = _session.QueryOver<Warehouse>().Cacheable().List();
_session.Transact(ses => warehouses.ForEach(warehouse => ses.Save(new WarehouseStock
{
StockLevel = 0,
ProductVariant = productVariant,
Warehouse = warehouse
})));
}
public int Get(ProductVariant productVariant)
{
return _ecommerceSettings.WarehouseStockEnabled
? _session.QueryOver<WarehouseStock>()
.Where(stock => stock.ProductVariant.Id == productVariant.Id && stock.StockLevel > 0)
.Select(Projections.Sum<WarehouseStock>(warehouseStock => warehouseStock.StockLevel))
.Cacheable()
.SingleOrDefault<int>()
: productVariant.StockRemaining;
}
//Ask gary for averaging
public decimal GetAverageRatingForProductVariant(ProductVariant productVariant)
{
if (
!GetBaseProductVariantReviewsQuery(_session.QueryOver<ProductReview>(), productVariant)
.Cacheable()
.Any())
return decimal.Zero;
return GetBaseProductVariantReviewsQuery(_session.QueryOver<ProductReview>(), productVariant)
.Select(x => x.Rating).Cacheable()
.List<int>().Select(Convert.ToDecimal).Average();
}
public CanBuyStatus CanBuy(ProductVariant productVariant, int quantity)
{
if (!_productStockChecker.IsInStock(productVariant))
return new OutOfStock(productVariant);
var result = _productStockChecker.CanOrderQuantity(productVariant, quantity);
if (!result.CanOrder)
return new CannotOrderQuantity(productVariant, result.StockRemaining);
if (!_productShippingChecker.CanShip(productVariant))
return new NoShippingMethodWouldBeAvailable(productVariant);
return new CanBuy();
}
private ProductOptionValue CreateValue(ProductVariant product, ProductOption option, string value)
{
var specValue = new ProductOptionValue
{
ProductVariant = product,
ProductOption = option,
Value = value
};
Session.Transact(session => session.Save(specValue));
return specValue;
}
public CanOrderQuantityResult CanOrderQuantity(ProductVariant productVariant, int quantity)
{
if (productVariant.TrackingPolicy == TrackingPolicy.DontTrack)
return new CanOrderQuantityResult {CanOrder = true};
var stockRemaining = _getStockRemainingQuantity.Get(productVariant);
return new CanOrderQuantityResult
{
CanOrder = stockRemaining >= quantity,
StockRemaining = stockRemaining
};
}
public bool UserNotifiedOfBackInStock(ProductVariant productVariant, bool justNotified)
{
if (justNotified)
return true;
var currentUser = CurrentRequestData.CurrentUser;
if (currentUser == null)
return false;
return
_session.QueryOver<BackInStockNotificationRequest>()
.Where(request => request.Email == currentUser.Email && request.ProductVariant == productVariant)
.Any();
}
public IPagedList<ProductReview> GetReviewsForVariant(ProductVariant productVariant, int pageNum,
int pageSize = 10)
{
ProductReview productReviewAlias = null;
return
GetBaseProductVariantReviewsQuery(_session.QueryOver(() => productReviewAlias), productVariant)
.OrderBy(
Projections.SubQuery(
QueryOver.Of<HelpfulnessVote>()
.Where(vote => vote.ProductReview.Id == productReviewAlias.Id && vote.IsHelpful)
.Select(Projections.Count<HelpfulnessVote>(x => x.Id)))).Desc
.Paged(pageNum, pageSize);
}
public void SetMethods(ProductVariant productVariant, NameValueCollection requestData)
{
productVariant.RestrictedTo.Clear();
if (!productVariant.HasRestrictedShipping)
{
return;
}
foreach (var key in requestData.AllKeys.Where(s => s.StartsWith(ShippingMethodPrefix))
.Where(key => requestData[key].Contains("true", StringComparison.OrdinalIgnoreCase)))
{
productVariant.RestrictedTo.Add(key.Replace(ShippingMethodPrefix, string.Empty));
}
}