/// <summary>
/// Calculates the unit price for a given shopping cart item.
/// </summary>
/// <param name="priceCalculationService">Price calculation service.</param>
/// <param name="cartItem">Shopping cart item.</param>
/// <param name="ignoreDiscounts">A value indicating whether to ignore discounts.</param>
/// <param name="targetCurrency">The target currency to use for money conversion. Obtained from <see cref="IWorkContext.WorkingCurrency"/> if <c>null</c>.</param>
/// <returns>Calculated unit price.</returns>
public static async Task <CalculatedPrice> CalculateUnitPriceAsync(
this IPriceCalculationService2 priceCalculationService,
OrganizedShoppingCartItem cartItem,
bool ignoreDiscounts = false,
Currency targetCurrency = null)
{
Guard.NotNull(priceCalculationService, nameof(priceCalculationService));
Guard.NotNull(cartItem, nameof(cartItem));
var options = priceCalculationService.CreateDefaultOptions(false, cartItem.Item.Customer, targetCurrency);
options.IgnoreDiscounts = ignoreDiscounts;
var context = new PriceCalculationContext(cartItem, options);
return(await priceCalculationService.CalculatePriceAsync(context));
}
/// <summary>
/// Gets the base price info for a product.
/// </summary>
/// <param name="priceCalculationService">Price calculation service.</param>
/// <param name="product">The product to get the base price info for.</param>
/// <param name="options">Price calculation options. The default options are used if <c>null</c>.</param>
/// <returns>Base price info.</returns>
public static async Task <string> GetBasePriceInfoAsync(this IPriceCalculationService2 priceCalculationService, Product product, PriceCalculationOptions options = null)
{
Guard.NotNull(priceCalculationService, nameof(priceCalculationService));
Guard.NotNull(product, nameof(product));
if (!product.BasePriceHasValue || product.BasePriceAmount == 0)
{
return(string.Empty);
}
options ??= priceCalculationService.CreateDefaultOptions(false);
var context = new PriceCalculationContext(product, options);
var price = await priceCalculationService.CalculatePriceAsync(context);
return(priceCalculationService.GetBasePriceInfo(product, price.FinalPrice, options.TargetCurrency));
}
/// <summary>
/// Calculates the unit price for a given shopping cart item.
/// </summary>
/// <param name="priceCalculationService">Price calculation service.</param>
/// <param name="cartItem">Shopping cart item.</param>
/// <param name="ignoreDiscounts">A value indicating whether to ignore discounts.</param>
/// <param name="targetCurrency">The target currency to use for money conversion. Obtained from <see cref="IWorkContext.WorkingCurrency"/> if <c>null</c>.</param>
/// <returns>Calculated unit price.</returns>
//public static async Task<CalculatedPrice> CalculateUnitPriceAsync(
// this IPriceCalculationService2 priceCalculationService,
// OrganizedShoppingCartItem cartItem,
// bool ignoreDiscounts = false,
// Currency targetCurrency = null)
//{
// Guard.NotNull(priceCalculationService, nameof(priceCalculationService));
// Guard.NotNull(cartItem, nameof(cartItem));
// var options = priceCalculationService.CreateDefaultOptions(false, cartItem.Item.Customer, targetCurrency);
// options.IgnoreDiscounts = ignoreDiscounts;
// var context = new PriceCalculationContext(cartItem, options);
// return await priceCalculationService.CalculatePriceAsync(context);
//}
/// <summary>
/// Calculates both the unit price and the subtotal for a given shopping cart item.
/// The subtotal is calculated by multiplying the unit price by <see cref="ShoppingCartItem.Quantity"/>.
/// </summary>
/// <param name="priceCalculationService">Price calculation service.</param>
/// <param name="cartItem">Shopping cart item.</param>
/// <param name="ignoreDiscounts">A value indicating whether to ignore discounts.</param>
/// <param name="targetCurrency">The target currency to use for money conversion. Obtained from <see cref="IWorkContext.WorkingCurrency"/> if <c>null</c>.</param>
/// <returns>Calculated subtotal.</returns>
//public static async Task<(CalculatedPrice UnitPrice, CalculatedPrice Subtotal)> CalculateSubtotalAsync(
// this IPriceCalculationService2 priceCalculationService,
// OrganizedShoppingCartItem cartItem,
// bool ignoreDiscounts = false,
// Currency targetCurrency = null)
//{
// Guard.NotNull(priceCalculationService, nameof(priceCalculationService));
// Guard.NotNull(cartItem, nameof(cartItem));
// var options = priceCalculationService.CreateDefaultOptions(false, cartItem.Item.Customer, targetCurrency);
// options.IgnoreDiscounts = ignoreDiscounts;
// var context = new PriceCalculationContext(cartItem, options);
// return await priceCalculationService.CalculateSubtotalAsync(context);
//}
/// <summary>
/// Calculates the price adjustments of product attributes, usually <see cref="ProductVariantAttributeValue.PriceAdjustment"/>.
/// Typically used to display price adjustments of selected attributes on the cart page.
/// The calculated adjustment is always a unit price.
/// </summary>
/// <param name="priceCalculationService">Price calculation service.</param>
/// <param name="product">The product.</param>
/// <param name="selection">Attribute selection.</param>
/// <param name="quantity">
/// The product quantity. May have impact on the price, e.g. if tier prices are applied to price adjustments.
/// Note that the calculated price is always the unit price.
/// </param>
/// <param name="options">Price calculation options. The default options are used if <c>null</c>.</param>
/// <returns>Price adjustments of selected attributes. Key: <see cref="ProductVariantAttributeValue.Id"/>, value: attribute price adjustment.</returns>
public static async Task <IDictionary <int, CalculatedPriceAdjustment> > CalculateAttributePriceAdjustmentsAsync(
this IPriceCalculationService2 priceCalculationService,
Product product,
ProductVariantAttributeSelection selection,
int quantity = 1,
PriceCalculationOptions options = null)
{
Guard.NotNull(priceCalculationService, nameof(priceCalculationService));
Guard.NotNull(selection, nameof(selection));
options ??= priceCalculationService.CreateDefaultOptions(false);
options.DeterminePriceAdjustments = true;
var pricingContext = new PriceCalculationContext(product, quantity, options);
pricingContext.AddSelectedAttributes(selection, product.Id);
var price = await priceCalculationService.CalculatePriceAsync(pricingContext);
return(price.AttributePriceAdjustments.ToDictionarySafe(x => x.AttributeValue.Id));
}
public virtual async Task <string> FormatAttributesAsync(
ProductVariantAttributeSelection selection,
Product product,
Customer customer = null,
string separator = "<br />",
bool htmlEncode = true,
bool includePrices = true,
bool includeProductAttributes = true,
bool includeGiftCardAttributes = true,
bool includeHyperlinks = true)
{
Guard.NotNull(selection, nameof(selection));
Guard.NotNull(product, nameof(product));
customer ??= _workContext.CurrentCustomer;
using var pool = StringBuilderPool.Instance.Get(out var result);
if (includeProductAttributes)
{
var languageId = _workContext.WorkingLanguage.Id;
var attributes = await _productAttributeMaterializer.MaterializeProductVariantAttributesAsync(selection);
var attributesDic = attributes.ToDictionary(x => x.Id);
// Key: ProductVariantAttributeValue.Id, value: calculated attribute price adjustment.
var priceAdjustments = includePrices && _catalogSettings.ShowVariantCombinationPriceAdjustment
? await _priceCalculationService.CalculateAttributePriceAdjustmentsAsync(product, selection, 1, _priceCalculationService.CreateDefaultOptions(false, customer))
: null;
CalculatedPriceAdjustment adjustment = null;
foreach (var kvp in selection.AttributesMap)
{
if (!attributesDic.TryGetValue(kvp.Key, out var pva))
{
continue;
}
foreach (var value in kvp.Value)
{
var valueStr = value.ToString().EmptyNull();
var pvaAttribute = string.Empty;
if (pva.IsListTypeAttribute())
{
var pvaValue = pva.ProductVariantAttributeValues.FirstOrDefault(x => x.Id == valueStr.ToInt());
if (pvaValue != null)
{
pvaAttribute = "{0}: {1}".FormatInvariant(
pva.ProductAttribute.GetLocalized(x => x.Name, languageId),
pvaValue.GetLocalized(x => x.Name, languageId));
if (includePrices)
{
if (_shoppingCartSettings.ShowLinkedAttributeValueQuantity &&
pvaValue.ValueType == ProductVariantAttributeValueType.ProductLinkage &&
pvaValue.Quantity > 1)
{
pvaAttribute = pvaAttribute + " × " + pvaValue.Quantity;
}
if (priceAdjustments?.TryGetValue(pvaValue.Id, out adjustment) ?? false)
{
if (adjustment.Price > decimal.Zero)
{
pvaAttribute += $" (+{adjustment.Price})";
}
else if (adjustment.Price < decimal.Zero)
{
pvaAttribute += $" (-{adjustment.Price * -1})";
}
}
}
if (htmlEncode)
{
pvaAttribute = pvaAttribute.HtmlEncode();
}
}
}
else if (pva.AttributeControlType == AttributeControlType.MultilineTextbox)
{
string attributeName = pva.ProductAttribute.GetLocalized(x => x.Name, languageId);
pvaAttribute = "{0}: {1}".FormatInvariant(
htmlEncode ? attributeName.HtmlEncode() : attributeName,
HtmlUtils.ConvertPlainTextToHtml(valueStr.HtmlEncode()));
}
else if (pva.AttributeControlType == AttributeControlType.FileUpload)
{
if (Guid.TryParse(valueStr, out var downloadGuid) && downloadGuid != Guid.Empty)
{
var download = await _db.Downloads
.AsNoTracking()
.Include(x => x.MediaFile)
.Where(x => x.DownloadGuid == downloadGuid)
.FirstOrDefaultAsync();
if (download?.MediaFile != null)
{
var attributeText = string.Empty;
var fileName = htmlEncode
? download.MediaFile.Name.HtmlEncode()
: download.MediaFile.Name;
if (includeHyperlinks)
{
// TODO: (core) add a method for getting URL (use routing because it handles all SEO friendly URLs).
var downloadLink = _webHelper.GetStoreLocation(false) + "download/getfileupload/?downloadId=" + download.DownloadGuid;
attributeText = $"<a href=\"{downloadLink}\" class=\"fileuploadattribute\">{fileName}</a>";
}
else
{
attributeText = fileName;
}
string attributeName = pva.ProductAttribute.GetLocalized(a => a.Name, languageId);
pvaAttribute = "{0}: {1}".FormatInvariant(
htmlEncode ? attributeName.HtmlEncode() : attributeName,
attributeText);
}
}
}
else
{
// TextBox, Datepicker
pvaAttribute = "{0}: {1}".FormatInvariant(pva.ProductAttribute.GetLocalized(x => x.Name, languageId), valueStr);
if (htmlEncode)
{
pvaAttribute = pvaAttribute.HtmlEncode();
}
}
result.Grow(pvaAttribute, separator);
}
}
}
if (includeGiftCardAttributes && product.IsGiftCard)
{
var gci = selection.GiftCardInfo;
if (gci != null)
{
// Sender.
var giftCardFrom = product.GiftCardType == GiftCardType.Virtual
? (await _localizationService.GetResourceAsync("GiftCardAttribute.From.Virtual")).FormatInvariant(gci.SenderName, gci.SenderEmail)
: (await _localizationService.GetResourceAsync("GiftCardAttribute.From.Physical")).FormatInvariant(gci.SenderName);
// Recipient.
var giftCardFor = product.GiftCardType == GiftCardType.Virtual
? (await _localizationService.GetResourceAsync("GiftCardAttribute.For.Virtual")).FormatInvariant(gci.RecipientName, gci.RecipientEmail)
: (await _localizationService.GetResourceAsync("GiftCardAttribute.For.Physical")).FormatInvariant(gci.RecipientName);
if (htmlEncode)
{
giftCardFrom = giftCardFrom.HtmlEncode();
giftCardFor = giftCardFor.HtmlEncode();
}
result.Grow(giftCardFrom, separator);
result.Grow(giftCardFor, separator);
}
}
return(result.ToString());
}
