public virtual decimal GetFinalPrice(
Product product,
IEnumerable <ProductBundleItemData> bundleItems,
Customer customer,
decimal additionalCharge,
bool includeDiscounts,
int quantity,
ProductBundleItemData bundleItem = null,
PriceCalculationContext context = null)
{
if (product.ProductType == ProductType.BundledProduct && product.BundlePerItemPricing)
{
decimal result = decimal.Zero;
var items = bundleItems ?? _productService.GetBundleItems(product.Id);
foreach (var itemData in items.Where(x => x.IsValid()))
{
decimal itemPrice = GetFinalPrice(itemData.Item.Product, customer, itemData.AdditionalCharge, includeDiscounts, 1, itemData, context);
result = result + decimal.Multiply(itemPrice, itemData.Item.Quantity);
}
return(result < decimal.Zero ? decimal.Zero : result);
}
return(GetFinalPrice(product, customer, additionalCharge, includeDiscounts, quantity, bundleItem, context));
}
public virtual decimal GetDiscountAmount(
Product product,
Customer customer,
decimal additionalCharge,
int quantity,
out Discount appliedDiscount,
ProductBundleItemData bundleItem = null,
PriceCalculationContext context = null)
{
appliedDiscount = null;
decimal appliedDiscountAmount = decimal.Zero;
decimal finalPriceWithoutDiscount = decimal.Zero;
if (bundleItem.IsValid())
{
if (bundleItem.Item.Discount.HasValue && bundleItem.Item.BundleProduct.BundlePerItemPricing)
{
appliedDiscount = new Discount
{
UsePercentage = bundleItem.Item.DiscountPercentage,
DiscountPercentage = bundleItem.Item.Discount.Value,
DiscountAmount = bundleItem.Item.Discount.Value
};
finalPriceWithoutDiscount = GetFinalPrice(product, customer, additionalCharge, false, quantity, bundleItem, context);
appliedDiscountAmount = appliedDiscount.GetDiscountAmount(finalPriceWithoutDiscount);
}
}
else
{
// dont't apply when customer entered price or discounts should be ignored completely
if (product.CustomerEntersPrice || _catalogSettings.IgnoreDiscounts)
{
return(appliedDiscountAmount);
}
var allowedDiscounts = GetAllowedDiscounts(product, customer, context);
if (allowedDiscounts.Count == 0)
{
return(appliedDiscountAmount);
}
finalPriceWithoutDiscount = GetFinalPrice(product, customer, additionalCharge, false, quantity, bundleItem, context);
appliedDiscount = allowedDiscounts.GetPreferredDiscount(finalPriceWithoutDiscount);
if (appliedDiscount != null)
{
appliedDiscountAmount = appliedDiscount.GetDiscountAmount(finalPriceWithoutDiscount);
}
}
return(appliedDiscountAmount);
}
public virtual PriceCalculationContext CreatePriceCalculationContext(IEnumerable <Product> products = null)
{
var context = new PriceCalculationContext(products,
x => _productAttributeService.GetProductVariantAttributesByProductIds(x, null),
x => _productAttributeService.GetProductVariantAttributeCombinations(x),
x => _productService.GetTierPricesByProductIds(x, _services.WorkContext.CurrentCustomer, _services.StoreContext.CurrentStore.Id),
x => _categoryService.GetProductCategoriesByProductIds(x, true),
x => _productService.GetAppliedDiscountsByProductIds(x)
);
return(context);
}
/// <summary>
/// Get the lowest possible price for a product.
/// </summary>
/// <param name="product">Product</param>
/// <param name="context">Object with cargo data for better performance</param>
/// <param name="displayFromMessage">Whether to display the from message.</param>
/// <returns>The lowest price.</returns>
public virtual decimal GetLowestPrice(Product product, PriceCalculationContext context, out bool displayFromMessage)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (product.ProductType == ProductType.GroupedProduct)
{
throw Error.InvalidOperation("Choose the other override for products of type grouped product.");
}
// note: attribute price adjustments were never regarded here cause of many reasons
if (context == null)
{
context = CreatePriceCalculationContext();
}
bool isBundlePerItemPricing = (product.ProductType == ProductType.BundledProduct && product.BundlePerItemPricing);
displayFromMessage = isBundlePerItemPricing;
var lowestPrice = GetFinalPrice(product, null, _services.WorkContext.CurrentCustomer, decimal.Zero, true, int.MaxValue, null, context);
if (product.LowestAttributeCombinationPrice.HasValue && product.LowestAttributeCombinationPrice.Value < lowestPrice)
{
lowestPrice = product.LowestAttributeCombinationPrice.Value;
displayFromMessage = true;
}
if (lowestPrice == decimal.Zero && product.Price == decimal.Zero)
{
lowestPrice = product.LowestAttributeCombinationPrice ?? decimal.Zero;
}
if (!displayFromMessage && product.ProductType != ProductType.BundledProduct)
{
var attributes = context.Attributes.Load(product.Id);
displayFromMessage = attributes.Any(x => x.ProductVariantAttributeValues.Any(y => y.PriceAdjustment != decimal.Zero));
}
if (!displayFromMessage && product.HasTierPrices && !isBundlePerItemPricing)
{
var tierPrices = context.TierPrices.Load(product.Id)
.RemoveDuplicatedQuantities();
displayFromMessage = (tierPrices.Count > 0 && !(tierPrices.Count == 1 && tierPrices.First().Quantity <= 1));
}
return(lowestPrice);
}
public virtual decimal?GetLowestPrice(Product product, PriceCalculationContext context, IEnumerable <Product> associatedProducts, out Product lowestPriceProduct)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
if (associatedProducts == null)
{
throw new ArgumentNullException("associatedProducts");
}
if (product.ProductType != ProductType.GroupedProduct)
{
throw Error.InvalidOperation("Choose the other override for products not of type grouped product.");
}
lowestPriceProduct = null;
decimal?lowestPrice = null;
var customer = _services.WorkContext.CurrentCustomer;
if (context == null)
{
context = CreatePriceCalculationContext();
}
foreach (var associatedProduct in associatedProducts)
{
var tmpPrice = GetFinalPrice(associatedProduct, customer, decimal.Zero, true, int.MaxValue, null, context);
if (associatedProduct.LowestAttributeCombinationPrice.HasValue && associatedProduct.LowestAttributeCombinationPrice.Value < tmpPrice)
{
tmpPrice = associatedProduct.LowestAttributeCombinationPrice.Value;
}
if (!lowestPrice.HasValue || tmpPrice < lowestPrice.Value)
{
lowestPrice = tmpPrice;
lowestPriceProduct = associatedProduct;
}
}
if (lowestPriceProduct == null)
{
lowestPriceProduct = associatedProducts.FirstOrDefault();
}
return(lowestPrice);
}
public virtual decimal GetFinalPrice(
Product product,
Customer customer,
decimal additionalCharge,
bool includeDiscounts,
int quantity,
ProductBundleItemData bundleItem = null,
PriceCalculationContext context = null)
{
//initial price
decimal result = product.Price;
//special price
var specialPrice = GetSpecialPrice(product);
if (specialPrice.HasValue)
{
result = specialPrice.Value;
}
//tier prices
if (product.HasTierPrices && !bundleItem.IsValid())
{
decimal?tierPrice = GetMinimumTierPrice(product, customer, quantity, context);
if (tierPrice.HasValue)
{
result = Math.Min(result, tierPrice.Value);
}
}
//discount + additional charge
if (includeDiscounts)
{
Discount appliedDiscount = null;
decimal discountAmount = GetDiscountAmount(product, customer, additionalCharge, quantity, out appliedDiscount, bundleItem, context);
result = result + additionalCharge - discountAmount;
}
else
{
result = result + additionalCharge;
}
if (result < decimal.Zero)
{
result = decimal.Zero;
}
return(result);
}
/// <summary>
/// Get the initial price including preselected attributes
/// </summary>
/// <param name="product">Product</param>
/// <param name="context">Object with cargo data for better performance</param>
/// <returns>Preselected price</returns>
public virtual decimal GetPreselectedPrice(Product product, PriceCalculationContext context)
{
if (product == null)
{
throw new ArgumentNullException("product");
}
var result = decimal.Zero;
if (context == null)
{
context = CreatePriceCalculationContext();
}
if (product.ProductType == ProductType.BundledProduct)
{
var bundleItems = _productService.GetBundleItems(product.Id);
var productIds = bundleItems.Select(x => x.Item.ProductId).ToList();
productIds.Add(product.Id);
context.Collect(productIds);
foreach (var bundleItem in bundleItems.Where(x => x.Item.Product.CanBeBundleItem()))
{
// fetch bundleItems.AdditionalCharge for all bundle items
var unused = GetPreselectedPrice(bundleItem.Item.Product, context, bundleItem, bundleItems);
}
result = GetPreselectedPrice(product, context, null, bundleItems);
}
else
{
result = GetPreselectedPrice(product, context, null, null);
}
return(result);
}
/// <summary>
/// Gets allowed discounts
/// </summary>
/// <param name="product">Product</param>
/// <param name="customer">Customer</param>
/// <returns>Discounts</returns>
protected virtual IList <Discount> GetAllowedDiscounts(Product product, Customer customer, PriceCalculationContext context = null)
{
var result = new List <Discount>();
if (_catalogSettings.IgnoreDiscounts)
{
return(result);
}
if (product.HasDiscountsApplied)
{
//we use this property ("HasDiscountsApplied") for performance optimziation to avoid unnecessary database calls
IEnumerable <Discount> appliedDiscounts = null;
if (context == null)
{
appliedDiscounts = product.AppliedDiscounts;
}
else
{
appliedDiscounts = context.AppliedDiscounts.Load(product.Id);
}
if (appliedDiscounts != null)
{
foreach (var discount in appliedDiscounts)
{
if (discount.DiscountType == DiscountType.AssignedToSkus && !result.Any(x => x.Id == discount.Id) && _discountService.IsDiscountValid(discount, customer))
{
result.Add(discount);
}
}
}
}
//performance optimization. load all category discounts just to ensure that we have at least one
if (_discountService.GetAllDiscounts(DiscountType.AssignedToCategories).Any())
{
IEnumerable <ProductCategory> productCategories = null;
if (context == null)
{
productCategories = _categoryService.GetProductCategoriesByProductId(product.Id);
}
else
{
productCategories = context.ProductCategories.Load(product.Id);
}
if (productCategories != null)
{
foreach (var productCategory in productCategories)
{
var category = productCategory.Category;
if (category.HasDiscountsApplied)
{
//we use this property ("HasDiscountsApplied") for performance optimziation to avoid unnecessary database calls
var categoryDiscounts = category.AppliedDiscounts;
foreach (var discount in categoryDiscounts)
{
if (discount.DiscountType == DiscountType.AssignedToCategories && !result.Any(x => x.Id == discount.Id) && _discountService.IsDiscountValid(discount, customer))
{
result.Add(discount);
}
}
}
}
}
}
return(result);
}
protected virtual decimal GetPreselectedPrice(Product product, PriceCalculationContext context, ProductBundleItemData bundleItem, IEnumerable <ProductBundleItemData> bundleItems)
{
var taxRate = decimal.Zero;
var attributesTotalPriceBase = decimal.Zero;
var preSelectedPriceAdjustmentBase = decimal.Zero;
var isBundle = (product.ProductType == ProductType.BundledProduct);
var isBundleItemPricing = (bundleItem != null && bundleItem.Item.BundleProduct.BundlePerItemPricing);
var isBundlePricing = (bundleItem != null && !bundleItem.Item.BundleProduct.BundlePerItemPricing);
var bundleItemId = (bundleItem == null ? 0 : bundleItem.Item.Id);
var selectedAttributes = new NameValueCollection();
var selectedAttributeValues = new List <ProductVariantAttributeValue>();
var attributes = context.Attributes.Load(product.Id);
// 1. fill selectedAttributes with initially selected attributes
foreach (var attribute in attributes.Where(x => x.ProductVariantAttributeValues.Count > 0 && x.ShouldHaveValues()))
{
int preSelectedValueId = 0;
ProductVariantAttributeValue defaultValue = null;
var selectedValueIds = new List <int>();
var pvaValues = attribute.ProductVariantAttributeValues;
foreach (var pvaValue in pvaValues)
{
ProductBundleItemAttributeFilter attributeFilter = null;
if (bundleItem.FilterOut(pvaValue, out attributeFilter))
{
continue;
}
if (preSelectedValueId == 0 && attributeFilter != null && attributeFilter.IsPreSelected)
{
preSelectedValueId = attributeFilter.AttributeValueId;
}
if (!isBundlePricing && pvaValue.IsPreSelected)
{
decimal attributeValuePriceAdjustment = GetProductVariantAttributeValuePriceAdjustment(pvaValue);
decimal priceAdjustmentBase = _taxService.GetProductPrice(product, attributeValuePriceAdjustment, out taxRate);
preSelectedPriceAdjustmentBase = decimal.Add(preSelectedPriceAdjustmentBase, priceAdjustmentBase);
}
}
// value pre-selected by a bundle item filter discards the default pre-selection
if (preSelectedValueId != 0 && (defaultValue = pvaValues.FirstOrDefault(x => x.Id == preSelectedValueId)) != null)
{
//defaultValue.IsPreSelected = true;
selectedAttributeValues.Add(defaultValue);
selectedAttributes.AddProductAttribute(attribute.ProductAttributeId, attribute.Id, defaultValue.Id, product.Id, bundleItemId);
}
else
{
foreach (var value in pvaValues.Where(x => x.IsPreSelected))
{
selectedAttributeValues.Add(value);
selectedAttributes.AddProductAttribute(attribute.ProductAttributeId, attribute.Id, value.Id, product.Id, bundleItemId);
}
}
}
// 2. find attribute combination for selected attributes and merge it
if (!isBundle && selectedAttributes.Count > 0)
{
var attributeXml = selectedAttributes.CreateSelectedAttributesXml(product.Id, attributes, _productAttributeParser, _services.Localization,
_downloadService, _catalogSettings, _httpRequestBase, new List <string>(), true, bundleItemId);
var combinations = context.AttributeCombinations.Load(product.Id);
var selectedCombination = combinations.FirstOrDefault(x => _productAttributeParser.AreProductAttributesEqual(x.AttributesXml, attributeXml));
if (selectedCombination != null && selectedCombination.IsActive && selectedCombination.Price.HasValue)
{
product.MergedDataValues = new Dictionary <string, object> {
{ "Price", selectedCombination.Price.Value }
};
if (selectedCombination.BasePriceAmount.HasValue)
{
product.MergedDataValues.Add("BasePriceAmount", selectedCombination.BasePriceAmount.Value);
}
if (selectedCombination.BasePriceBaseAmount.HasValue)
{
product.MergedDataValues.Add("BasePriceBaseAmount", selectedCombination.BasePriceBaseAmount.Value);
}
}
}
if (_catalogSettings.EnableDynamicPriceUpdate && !isBundlePricing)
{
if (selectedAttributeValues.Count > 0)
{
selectedAttributeValues.Each(x => attributesTotalPriceBase += GetProductVariantAttributeValuePriceAdjustment(x));
}
else
{
attributesTotalPriceBase = preSelectedPriceAdjustmentBase;
}
}
if (bundleItem != null)
{
bundleItem.AdditionalCharge = attributesTotalPriceBase;
}
var result = GetFinalPrice(product, bundleItems, _services.WorkContext.CurrentCustomer, attributesTotalPriceBase, true, 1, bundleItem, context);
return(result);
}
/// <summary>
/// Gets a tier price
/// </summary>
/// <param name="product">Product</param>
/// <param name="customer">Customer</param>
/// <param name="quantity">Quantity</param>
/// <returns>Price</returns>
protected virtual decimal?GetMinimumTierPrice(Product product, Customer customer, int quantity, PriceCalculationContext context = null)
{
if (!product.HasTierPrices)
{
return(decimal.Zero);
}
IEnumerable <TierPrice> tierPrices = null;
if (context == null)
{
tierPrices = product.TierPrices
.OrderBy(tp => tp.Quantity)
.FilterByStore(_services.StoreContext.CurrentStore.Id)
.FilterForCustomer(customer)
.ToList()
.RemoveDuplicatedQuantities();
}
else
{
tierPrices = context.TierPrices.Load(product.Id)
.RemoveDuplicatedQuantities();
}
if (tierPrices == null)
{
return(decimal.Zero);
}
int previousQty = 1;
decimal?previousPrice = null;
foreach (var tierPrice in tierPrices)
{
//check quantity
if (quantity < tierPrice.Quantity)
{
continue;
}
if (tierPrice.Quantity < previousQty)
{
continue;
}
//save new price
previousPrice = tierPrice.Price;
previousQty = tierPrice.Quantity;
}
return(previousPrice);
}
