public async Task <MiniShoppingCartModel> Handle(GetMiniShoppingCart request, CancellationToken cancellationToken)
{
var model = new MiniShoppingCartModel {
ShowProductImages = _shoppingCartSettings.ShowProductImagesInMiniShoppingCart,
DisplayShoppingCartButton = true,
CurrentCustomerIsGuest = request.Customer.IsGuest(),
AnonymousCheckoutAllowed = _orderSettings.AnonymousCheckoutAllowed,
};
if (request.Customer.ShoppingCartItems.Any())
{
var shoppingCartTypes = new List <ShoppingCartType>();
shoppingCartTypes.Add(ShoppingCartType.ShoppingCart);
shoppingCartTypes.Add(ShoppingCartType.Auctions);
if (_shoppingCartSettings.AllowOnHoldCart)
{
shoppingCartTypes.Add(ShoppingCartType.OnHoldCart);
}
var cart = _shoppingCartService.GetShoppingCart(request.Store.Id, shoppingCartTypes.ToArray());
model.TotalProducts = cart.Sum(x => x.Quantity);
if (cart.Any())
{
//subtotal
var subTotalIncludingTax = request.TaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal;
var shoppingCartSubTotal = await _orderTotalCalculationService.GetShoppingCartSubTotal(cart, subTotalIncludingTax);
decimal orderSubTotalDiscountAmountBase = shoppingCartSubTotal.discountAmount;
List <AppliedDiscount> orderSubTotalAppliedDiscounts = shoppingCartSubTotal.appliedDiscounts;
decimal subTotalWithoutDiscountBase = shoppingCartSubTotal.subTotalWithoutDiscount;
decimal subTotalWithDiscountBase = shoppingCartSubTotal.subTotalWithDiscount;
decimal subtotalBase = subTotalWithoutDiscountBase;
decimal subtotal = await _currencyService.ConvertFromPrimaryStoreCurrency(subtotalBase, request.Currency);
model.SubTotal = _priceFormatter.FormatPrice(subtotal, false, request.Currency, request.Language, subTotalIncludingTax);
var requiresShipping = cart.RequiresShipping();
//a customer should visit the shopping cart page (hide checkout button) before going to checkout if:
//1. "terms of service" are enabled
//2. min order sub-total is OK
//3. we have at least one checkout attribute
var checkoutAttributesExistCacheKey = string.Format(ModelCacheEventConst.CHECKOUTATTRIBUTES_EXIST_KEY,
request.Store.Id, requiresShipping);
var checkoutAttributesExist = await _cacheManager.GetAsync(checkoutAttributesExistCacheKey, async() =>
{
var checkoutAttributes = await _checkoutAttributeService.GetAllCheckoutAttributes(request.Store.Id, !requiresShipping);
return(checkoutAttributes.Any());
});
bool minOrderSubtotalAmountOk = await _orderProcessingService.ValidateMinOrderSubtotalAmount(cart.Where
(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart || x.ShoppingCartType == ShoppingCartType.Auctions).ToList());
model.DisplayCheckoutButton = !_orderSettings.TermsOfServiceOnShoppingCartPage &&
minOrderSubtotalAmountOk &&
!checkoutAttributesExist;
//products. sort descending (recently added products)
foreach (var sci in cart
.OrderByDescending(x => x.Id)
.Take(_shoppingCartSettings.MiniShoppingCartProductNumber)
.ToList())
{
var product = await _productService.GetProductById(sci.ProductId);
var cartItemModel = new MiniShoppingCartModel.ShoppingCartItemModel {
Id = sci.Id,
ProductId = product.Id,
ProductName = product.GetLocalized(x => x.Name, request.Language.Id),
ProductSeName = product.GetSeName(request.Language.Id),
Quantity = sci.Quantity,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.AttributesXml)
};
if (product.ProductType == ProductType.Reservation)
{
var reservation = "";
if (sci.RentalEndDateUtc == default(DateTime) || sci.RentalEndDateUtc == null)
{
reservation = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.StartDate"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
else
{
reservation = string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Date"), sci.RentalStartDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat), sci.RentalEndDateUtc?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
if (!string.IsNullOrEmpty(sci.Parameter))
{
reservation += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Option"), sci.Parameter);
}
if (!string.IsNullOrEmpty(sci.Duration))
{
reservation += "<br>" + string.Format(_localizationService.GetResource("ShoppingCart.Reservation.Duration"), sci.Duration);
}
if (string.IsNullOrEmpty(cartItemModel.AttributeInfo))
{
cartItemModel.AttributeInfo = reservation;
}
else
{
cartItemModel.AttributeInfo += "<br>" + reservation;
}
}
//unit prices
if (product.CallForPrice)
{
cartItemModel.UnitPrice = _localizationService.GetResource("Products.CallForPrice");
}
else
{
var productprices = await _taxService.GetProductPrice(product, (await _priceCalculationService.GetUnitPrice(sci)).unitprice);
decimal taxRate = productprices.taxRate;
decimal shoppingCartUnitPriceWithDiscountBase = productprices.productprice;
decimal shoppingCartUnitPriceWithDiscount = await _currencyService.ConvertFromPrimaryStoreCurrency(shoppingCartUnitPriceWithDiscountBase, request.Currency);
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(shoppingCartUnitPriceWithDiscount);
}
//picture
if (_shoppingCartSettings.ShowProductImagesInMiniShoppingCart)
{
cartItemModel.Picture = await PrepareCartItemPicture(request, product, sci.AttributesXml);
}
model.Items.Add(cartItemModel);
}
}
}
return(model);
}
public CheckoutConfirmModel PrepareConfirmOrderModel(IList <ShoppingCartItem> cart)
{
var model = new CheckoutConfirmModel();
//min order amount validation
var minOrderTotalAmountOk = _orderProcessingService.ValidateMinOrderTotalAmount(cart);
if (minOrderTotalAmountOk)
{
return(model);
}
var minOrderTotalAmount = _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderTotalAmount, _workContext.WorkingCurrency);
model.MinOrderTotalWarning = string.Format(_localizationService.GetResource("Checkout.MinOrderTotalAmount"), _priceFormatter.FormatPrice(minOrderTotalAmount, true, false));
return(model);
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="product">Product</param>
/// <param name="attributes">Attributes</param>
/// <param name="customer">Customer</param>
/// <param name="serapator">Serapator</param>
/// <param name="htmlEncode">A value indicating whether to encode (HTML) values</param>
/// <param name="renderPrices">A value indicating whether to render prices</param>
/// <param name="renderProductAttributes">A value indicating whether to render product attributes</param>
/// <param name="renderGiftCardAttributes">A value indicating whether to render gift card attributes</param>
/// <param name="allowHyperlinks">A value indicating whether to HTML hyperink tags could be rendered (if required)</param>
/// <returns>Attributes</returns>
public string FormatAttributes(Product product, string attributes,
Customer customer, string serapator = "<br />", bool htmlEncode = true, bool renderPrices = true,
bool renderProductAttributes = true, bool renderGiftCardAttributes = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
var languageId = _workContext.WorkingLanguage.Id;
// Attributes
if (renderProductAttributes)
{
var pvaCollection = _productAttributeParser.ParseProductVariantAttributes(attributes);
for (int i = 0; i < pvaCollection.Count; i++)
{
var pva = pvaCollection[i];
var valuesStr = _productAttributeParser.ParseValues(attributes, pva.Id);
for (int j = 0; j < valuesStr.Count; j++)
{
string valueStr = valuesStr[j];
string pvaAttribute = string.Empty;
if (!pva.ShouldHaveValues())
{
//no values
if (pva.AttributeControlType == AttributeControlType.MultilineTextbox)
{
//multiline textbox
string attributeName = pva.ProductAttribute.GetLocalized(a => a.Name, languageId);
//encode (if required)
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
pvaAttribute = string.Format("{0}: {1}", attributeName, HtmlUtils.FormatText(valueStr, false, true, false, false, false, false));
//we never encode multiline textbox input
}
else if (pva.AttributeControlType == AttributeControlType.FileUpload)
{
//file upload
Guid downloadGuid;
Guid.TryParse(valueStr, out downloadGuid);
var download = _downloadService.GetDownloadByGuid(downloadGuid);
if (download != null)
{
//TODO add a method for getting URL (use routing because it handles all SEO friendly URLs)
string attributeText = "";
var fileName = string.Format("{0}{1}",
download.Filename ?? download.DownloadGuid.ToString(),
download.Extension);
//encode (if required)
if (htmlEncode)
{
fileName = HttpUtility.HtmlEncode(fileName);
}
if (allowHyperlinks)
{
//hyperlinks are allowed
var downloadLink = string.Format("{0}download/getfileupload/?downloadId={1}", _webHelper.GetStoreLocation(false), download.DownloadGuid);
attributeText = string.Format("<a href=\"{0}\" class=\"fileuploadattribute\">{1}</a>", downloadLink, fileName);
}
else
{
//hyperlinks aren't allowed
attributeText = fileName;
}
string attributeName = pva.ProductAttribute.GetLocalized(a => a.Name, languageId);
//encode (if required)
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
pvaAttribute = string.Format("{0}: {1}", attributeName, attributeText);
}
}
else
{
//other attributes (textbox, datepicker)
pvaAttribute = string.Format("{0}: {1}", pva.ProductAttribute.GetLocalized(a => a.Name, languageId), valueStr);
//encode (if required)
if (htmlEncode)
{
pvaAttribute = HttpUtility.HtmlEncode(pvaAttribute);
}
}
}
else
{
// Attributes with values.
int pvaId = 0;
if (int.TryParse(valueStr, out pvaId))
{
var pvaValue = _productAttributeService.GetProductVariantAttributeValueById(pvaId);
if (pvaValue != null)
{
pvaAttribute = "{0}: {1}".FormatInvariant(
pva.ProductAttribute.GetLocalized(a => a.Name, languageId),
pvaValue.GetLocalized(a => a.Name, languageId));
if (renderPrices)
{
decimal taxRate = decimal.Zero;
decimal attributeValuePriceAdjustment = _priceCalculationService.GetProductVariantAttributeValuePriceAdjustment(pvaValue, product, customer, null, 1);
decimal priceAdjustmentBase = _taxService.GetProductPrice(product, attributeValuePriceAdjustment, customer, out taxRate);
decimal priceAdjustment = _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, _workContext.WorkingCurrency);
if (_shoppingCartSettings.ShowLinkedAttributeValueQuantity && pvaValue.ValueType == ProductVariantAttributeValueType.ProductLinkage &&
pvaValue.Quantity > 1)
{
pvaAttribute += string.Format(" × {0}", pvaValue.Quantity);
}
if (_catalogSettings.ShowVariantCombinationPriceAdjustment)
{
if (priceAdjustmentBase > 0)
{
pvaAttribute += " (+{0})".FormatInvariant(_priceFormatter.FormatPrice(priceAdjustment, true, false));
}
else if (priceAdjustmentBase < decimal.Zero)
{
pvaAttribute += " (-{0})".FormatInvariant(_priceFormatter.FormatPrice(-priceAdjustment, true, false));
}
}
}
}
// Encode (if required)
if (htmlEncode)
{
pvaAttribute = HttpUtility.HtmlEncode(pvaAttribute);
}
}
}
if (!String.IsNullOrEmpty(pvaAttribute))
{
if (i != 0 || j != 0)
{
result.Append(serapator);
}
result.Append(pvaAttribute);
}
}
}
}
//gift cards
if (renderGiftCardAttributes)
{
if (product.IsGiftCard)
{
string giftCardRecipientName = "";
string giftCardRecipientEmail = "";
string giftCardSenderName = "";
string giftCardSenderEmail = "";
string giftCardMessage = "";
_productAttributeParser.GetGiftCardAttribute(attributes, out giftCardRecipientName, out giftCardRecipientEmail,
out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
//sender
var giftCardFrom = product.GiftCardType == GiftCardType.Virtual ?
string.Format(_localizationService.GetResource("GiftCardAttribute.From.Virtual"), giftCardSenderName, giftCardSenderEmail) :
string.Format(_localizationService.GetResource("GiftCardAttribute.From.Physical"), giftCardSenderName);
//recipient
var giftCardFor = product.GiftCardType == GiftCardType.Virtual ?
string.Format(_localizationService.GetResource("GiftCardAttribute.For.Virtual"), giftCardRecipientName, giftCardRecipientEmail) :
string.Format(_localizationService.GetResource("GiftCardAttribute.For.Physical"), giftCardRecipientName);
//encode (if required)
if (htmlEncode)
{
giftCardFrom = HttpUtility.HtmlEncode(giftCardFrom);
giftCardFor = HttpUtility.HtmlEncode(giftCardFor);
}
if (!String.IsNullOrEmpty(result.ToString()))
{
result.Append(serapator);
}
result.Append(giftCardFrom);
result.Append(serapator);
result.Append(giftCardFor);
}
}
return(result.ToString());
}
public virtual async Task <CheckoutPaymentMethodModel> PreparePaymentMethod(IList <ShoppingCartItem> cart, string filterByCountryId)
{
var model = new CheckoutPaymentMethodModel();
//reward points
if (_rewardPointsSettings.Enabled && !cart.IsRecurring())
{
int rewardPointsBalance = await _rewardPointsService.GetRewardPointsBalance(_workContext.CurrentCustomer.Id, _storeContext.CurrentStore.Id);
decimal rewardPointsAmountBase = await _orderTotalCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
decimal rewardPointsAmount = await _currencyService.ConvertFromPrimaryStoreCurrency(rewardPointsAmountBase, _workContext.WorkingCurrency);
if (rewardPointsAmount > decimal.Zero &&
_orderTotalCalculationService.CheckMinimumRewardPointsToUseRequirement(rewardPointsBalance))
{
model.DisplayRewardPoints = true;
model.RewardPointsAmount = _priceFormatter.FormatPrice(rewardPointsAmount, true, false);
model.RewardPointsBalance = rewardPointsBalance;
model.RewardPointsEnoughToPayForOrder = !(await IsPaymentWorkflowRequired(cart, true));
}
}
//filter by country
var paymentMethods = (await _paymentService
.LoadActivePaymentMethods(_workContext.CurrentCustomer, _storeContext.CurrentStore.Id, filterByCountryId))
.Where(pm => pm.PaymentMethodType == PaymentMethodType.Standard || pm.PaymentMethodType == PaymentMethodType.Redirection).ToList();
var availablepaymentMethods = new List <IPaymentMethod>();
foreach (var pm in paymentMethods)
{
if (!await pm.HidePaymentMethod(cart))
{
availablepaymentMethods.Add(pm);
}
}
foreach (var pm in availablepaymentMethods)
{
if (cart.IsRecurring() && pm.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
var pmModel = new CheckoutPaymentMethodModel.PaymentMethodModel
{
Name = pm.GetLocalizedFriendlyName(_localizationService, _workContext.WorkingLanguage.Id),
Description = _paymentSettings.ShowPaymentMethodDescriptions ? await pm.PaymentMethodDescription() : string.Empty,
PaymentMethodSystemName = pm.PluginDescriptor.SystemName,
LogoUrl = pm.PluginDescriptor.GetLogoUrl(_webHelper)
};
//payment method additional fee
decimal paymentMethodAdditionalFee = await _paymentService.GetAdditionalHandlingFee(cart, pm.PluginDescriptor.SystemName);
decimal rateBase = (await _taxService.GetPaymentMethodAdditionalFee(paymentMethodAdditionalFee, _workContext.CurrentCustomer)).paymentPrice;
decimal rate = await _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
if (rate > decimal.Zero)
{
pmModel.Fee = _priceFormatter.FormatPaymentMethodAdditionalFee(rate, true);
}
model.PaymentMethods.Add(pmModel);
}
//find a selected (previously) payment method
var selectedPaymentMethodSystemName = await _workContext.CurrentCustomer.GetAttribute <string>(
_genericAttributeService, SystemCustomerAttributeNames.SelectedPaymentMethod, _storeContext.CurrentStore.Id);
if (!String.IsNullOrEmpty(selectedPaymentMethodSystemName))
{
var paymentMethodToSelect = model.PaymentMethods.ToList()
.Find(pm => pm.PaymentMethodSystemName.Equals(selectedPaymentMethodSystemName, StringComparison.OrdinalIgnoreCase));
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
}
}
//if no option has been selected, let's do it for the first one
if (model.PaymentMethods.FirstOrDefault(so => so.Selected) == null)
{
var paymentMethodToSelect = model.PaymentMethods.FirstOrDefault();
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
}
}
return(model);
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="request">A request for getting shipping options</param>
/// <returns>Represents a response of getting shipping rate options</returns>
public GetShippingOptionResponse GetShippingOptions(GetShippingOptionRequest request)
{
if (request == null)
{
throw new ArgumentNullException("getShippingOptionRequest");
}
var response = new GetShippingOptionResponse();
if (request.Items == null || request.Items.Count == 0)
{
response.AddError(T("Admin.System.Warnings.NoShipmentItems"));
return(response);
}
int storeId = request.StoreId > 0 ? request.StoreId : _storeContext.CurrentStore.Id;
var taxRate = decimal.Zero;
decimal subTotal = decimal.Zero;
int countryId = 0;
string zip = null;
if (request.ShippingAddress != null)
{
countryId = request.ShippingAddress.CountryId ?? 0;
zip = request.ShippingAddress.ZipPostalCode;
}
foreach (var shoppingCartItem in request.Items)
{
if (shoppingCartItem.Item.IsFreeShipping || !shoppingCartItem.Item.IsShipEnabled)
{
continue;
}
var itemSubTotal = _priceCalculationService.GetSubTotal(shoppingCartItem, true);
var itemSubTotalInclTax = _taxService.GetProductPrice(shoppingCartItem.Item.Product, itemSubTotal, true, request.Customer, out taxRate);
subTotal += itemSubTotalInclTax;
}
var weight = _shippingService.GetShoppingCartTotalWeight(request.Items, _shippingByWeightSettings.IncludeWeightOfFreeShippingProducts);
var shippingMethods = _shippingService.GetAllShippingMethods(request);
foreach (var shippingMethod in shippingMethods)
{
var record = _shippingByWeightService.FindRecord(shippingMethod.Id, storeId, countryId, weight, zip);
decimal?rate = GetRate(subTotal, weight, shippingMethod.Id, storeId, countryId, zip);
if (rate.HasValue)
{
var shippingOption = new ShippingOption();
shippingOption.ShippingMethodId = shippingMethod.Id;
shippingOption.Name = shippingMethod.GetLocalized(x => x.Name);
if (record != null && record.SmallQuantityThreshold > subTotal)
{
shippingOption.Description = shippingMethod.GetLocalized(x => x.Description)
+ _localizationService.GetResource("Plugin.Shipping.ByWeight.SmallQuantitySurchargeNotReached").FormatWith(
_priceFormatter.FormatPrice(record.SmallQuantitySurcharge),
_priceFormatter.FormatPrice(record.SmallQuantityThreshold));
shippingOption.Rate = rate.Value + record.SmallQuantitySurcharge;
}
else
{
shippingOption.Description = shippingMethod.GetLocalized(x => x.Description);
shippingOption.Rate = rate.Value;
}
response.ShippingOptions.Add(shippingOption);
}
}
return(response);
}
protected SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
string returnRequestReasons = _orderSettings.GetLocalized(x => x.ReturnRequestReasons, order.CustomerLanguageId, true, false);
string returnRequestActions = _orderSettings.GetLocalized(x => x.ReturnRequestActions, order.CustomerLanguageId, true, false);
//return reasons
foreach (var rrr in returnRequestReasons.SplitSafe(","))
{
model.AvailableReturnReasons.Add(new SelectListItem()
{
Text = rrr, Value = rrr
});
}
//return actions
foreach (var rra in returnRequestActions.SplitSafe(","))
{
model.AvailableReturnActions.Add(new SelectListItem()
{
Text = rra, Value = rra
});
}
//products
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var attributeQueryData = new List <List <int> >();
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
AttributeInfo = orderItem.AttributeDescription,
Quantity = orderItem.Quantity
};
if (orderItem.Product.ProductType != ProductType.BundledProduct)
{
_productAttributeParser.DeserializeQueryData(attributeQueryData, orderItem.AttributesXml, orderItem.ProductId);
}
else if (orderItem.Product.BundlePerItemPricing && orderItem.BundleData.HasValue())
{
var bundleData = orderItem.GetBundleData();
bundleData.ForEach(x => _productAttributeParser.DeserializeQueryData(attributeQueryData, x.AttributesXml, x.ProductId, x.BundleItemId));
}
orderItemModel.ProductUrl = _productAttributeParser.GetProductUrlWithAttributes(attributeQueryData, orderItemModel.ProductSeName);
//unit price
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
break;
}
model.Items.Add(orderItemModel);
}
return(model);
}
public async Task <AddToCartModel> Handle(GetAddToCart request, CancellationToken cancellationToken)
{
var model = new AddToCartModel
{
AttributeDescription = await _productAttributeFormatter.FormatAttributes(request.Product, request.Attributes),
ProductSeName = request.Product.GetSeName(request.Language.Id),
CartType = request.CartType,
ProductId = request.Product.Id,
ProductName = request.Product.GetTranslation(x => x.Name, request.Language.Id),
Quantity = request.Quantity
};
//reservation info
if (request.Product.ProductTypeId == ProductType.Reservation)
{
if (request.EndDate == default(DateTime) || request.EndDate == null)
{
model.ReservationInfo = string.Format(_translationService.GetResource("ShoppingCart.Reservation.StartDate"), request.StartDate?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
else
{
model.ReservationInfo = string.Format(_translationService.GetResource("ShoppingCart.Reservation.Date"), request.StartDate?.ToString(_shoppingCartSettings.ReservationDateFormat), request.EndDate?.ToString(_shoppingCartSettings.ReservationDateFormat));
}
if (!string.IsNullOrEmpty(request.Parameter))
{
model.ReservationInfo += "<br>" + string.Format(_translationService.GetResource("ShoppingCart.Reservation.Option"), request.Parameter);
}
if (!string.IsNullOrEmpty(request.Duration))
{
model.ReservationInfo += "<br>" + string.Format(_translationService.GetResource("ShoppingCart.Reservation.Duration"), request.Duration);
}
}
if (request.CartType != ShoppingCartType.Auctions)
{
var cartItems = request.Customer.ShoppingCartItems
.Where(x => x.ShoppingCartTypeId == request.CartType &&
x.ProductId == request.Product.Id &&
x.EnteredPrice == request.CustomerEnteredPrice);
if (request.Attributes != null && request.Attributes.Any() && cartItems.Count() > 1)
{
cartItems = cartItems.Where(x => x.Attributes.All(y => request.Attributes.Any(z => z.Key == y.Key && z.Value == y.Value)));
}
var sci = cartItems.FirstOrDefault();
model.ItemQuantity = sci.Quantity;
//unit prices
if (request.Product.CallForPrice)
{
model.Price = _translationService.GetResource("Products.CallForPrice");
}
else
{
var productprices = await _taxService.GetProductPrice(request.Product, (await _pricingService.GetUnitPrice(sci, request.Product)).unitprice);
decimal taxRate = productprices.taxRate;
model.Price = !request.CustomerEnteredPrice.HasValue ? _priceFormatter.FormatPrice(productprices.productprice) : _priceFormatter.FormatPrice(request.CustomerEnteredPrice.Value);
model.DecimalPrice = request.CustomerEnteredPrice ?? productprices.productprice;
model.TotalPrice = _priceFormatter.FormatPrice(productprices.productprice * sci.Quantity);
}
//picture
model.Picture = await PrepareCartItemPicture(request);
}
else
{
model.Picture = await PrepareCartItemPicture(request);
}
var cart = _shoppingCartService.GetShoppingCart(request.Store.Id, request.CartType);
if (request.CartType != ShoppingCartType.Auctions)
{
model.TotalItems = cart.Sum(x => x.Quantity);
}
else
{
model.TotalItems = 0;
var grouped = (await _auctionService.GetBidsByCustomerId(request.Customer.Id)).GroupBy(x => x.ProductId);
foreach (var item in grouped)
{
var p = await _productService.GetProductById(item.Key);
if (p != null && p.AvailableEndDateTimeUtc > DateTime.UtcNow)
{
model.TotalItems++;
}
}
}
if (request.CartType == ShoppingCartType.ShoppingCart)
{
var subTotalIncludingTax = request.TaxDisplayType == TaxDisplayType.IncludingTax && !_taxSettings.ForceTaxExclusionFromOrderSubtotal;
var shoppingCartSubTotal = await _orderTotalCalculationService.GetShoppingCartSubTotal(cart, subTotalIncludingTax);
List <ApplyDiscount> orderSubTotalAppliedDiscounts = shoppingCartSubTotal.appliedDiscounts;
decimal subTotalWithDiscountBase = shoppingCartSubTotal.subTotalWithDiscount;
model.SubTotal = _priceFormatter.FormatPrice(shoppingCartSubTotal.subTotalWithoutDiscount, request.Currency, request.Language, subTotalIncludingTax);
model.DecimalSubTotal = shoppingCartSubTotal.subTotalWithoutDiscount;
if (shoppingCartSubTotal.discountAmount > decimal.Zero)
{
model.SubTotalDiscount = _priceFormatter.FormatPrice(-shoppingCartSubTotal.discountAmount, request.Currency, request.Language, subTotalIncludingTax);
}
}
else if (request.CartType == ShoppingCartType.Auctions)
{
model.IsAuction = true;
model.HighestBidValue = request.Product.HighestBid;
model.HighestBid = _priceFormatter.FormatPrice(request.Product.HighestBid);
model.EndTime = request.Product.AvailableEndDateTimeUtc;
}
return(model);
}
/// <summary>
/// Print an order to PDF
/// </summary>
/// <param name="order">Order</param>
/// <param name="lang">Language</param>
/// <param name="filePath">File path</param>
public virtual void PrintOrderToPdf(Order order, Language lang, string filePath)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (lang == null)
{
throw new ArgumentNullException("lang");
}
if (String.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath");
}
var pageSize = PageSize.A4;
if (_pdfSettings.LetterPageSizeEnabled)
{
pageSize = PageSize.LETTER;
}
var doc = new Document(pageSize);
PdfWriter.GetInstance(doc, new FileStream(filePath, FileMode.Create));
doc.Open();
//fonts
var titleFont = GetFont();
titleFont.SetStyle(Font.BOLD);
titleFont.Color = BaseColor.BLACK;
var font = GetFont();
var attributesFont = GetFont();
attributesFont.SetStyle(Font.ITALIC);
#region Header
//logo
var logoPicture = _pictureService.GetPictureById(_pdfSettings.LogoPictureId);
var logoExists = logoPicture != null;
//header
var headerTable = new PdfPTable(logoExists ? 2 : 1);
headerTable.WidthPercentage = 100f;
if (logoExists)
{
headerTable.SetWidths(new[] { 50, 50 });
}
//logo
if (logoExists)
{
var logoFilePath = _pictureService.GetPictureLocalPath(logoPicture, 0, false);
var cellLogo = new PdfPCell(Image.GetInstance(logoFilePath));
cellLogo.Border = Rectangle.NO_BORDER;
headerTable.AddCell(cellLogo);
}
//store info
var cell = new PdfPCell();
cell.Border = Rectangle.NO_BORDER;
cell.AddElement(new Paragraph(String.Format(_localizationService.GetResource("PDFInvoice.Order#", lang.Id), order.Id), titleFont));
var anchor = new Anchor(_storeInformationSettings.StoreUrl.Trim(new char[] { '/' }), font);
anchor.Reference = _storeInformationSettings.StoreUrl;
cell.AddElement(new Paragraph(anchor));
cell.AddElement(new Paragraph(String.Format(_localizationService.GetResource("PDFInvoice.OrderDate", lang.Id), _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc).ToString("D")), font));
headerTable.AddCell(cell);
doc.Add(headerTable);
#endregion
#region Addresses
var addressTable = new PdfPTable(2);
addressTable.WidthPercentage = 100f;
addressTable.SetWidths(new[] { 50, 50 });
//billing info
cell = new PdfPCell();
cell.Border = Rectangle.NO_BORDER;
cell.AddElement(new Paragraph(_localizationService.GetResource("PDFInvoice.BillingInformation", lang.Id), titleFont));
if (!String.IsNullOrEmpty(order.BillingAddress.Company))
{
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Company", lang.Id), order.BillingAddress.Company), font));
}
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Name", lang.Id), order.BillingAddress.FirstName + " " + order.BillingAddress.LastName), font));
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Phone", lang.Id), order.BillingAddress.PhoneNumber), font));
if (!String.IsNullOrEmpty(order.BillingAddress.FaxNumber))
{
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Fax", lang.Id), order.BillingAddress.FaxNumber), font));
}
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Address", lang.Id), order.BillingAddress.Address1), font));
if (!String.IsNullOrEmpty(order.BillingAddress.Address2))
{
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Address2", lang.Id), order.BillingAddress.Address2), font));
}
cell.AddElement(new Paragraph(" " + String.Format("{0}, {1} {2}", order.BillingAddress.City, order.BillingAddress.StateProvince != null ? order.BillingAddress.StateProvince.GetLocalized(x => x.Name) : "", order.BillingAddress.ZipPostalCode), font));
cell.AddElement(new Paragraph(" " + String.Format("{0}", order.BillingAddress.Country != null ? order.BillingAddress.Country.GetLocalized(x => x.Name) : ""), font));
//VAT number
if (!String.IsNullOrEmpty(order.VatNumber))
{
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.VATNumber", lang.Id), order.VatNumber), font));
}
addressTable.AddCell(cell);
//shipping info
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
if (order.ShippingAddress == null)
{
throw new NopException(string.Format("Shipping is required, but address is not available. Order ID = {0}", order.Id));
}
cell = new PdfPCell();
cell.Border = Rectangle.NO_BORDER;
cell.AddElement(new Paragraph(_localizationService.GetResource("PDFInvoice.ShippingInformation", lang.Id), titleFont));
if (!String.IsNullOrEmpty(order.ShippingAddress.Company))
{
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Company", lang.Id), order.ShippingAddress.Company), font));
}
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Name", lang.Id), order.ShippingAddress.FirstName + " " + order.ShippingAddress.LastName), font));
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Phone", lang.Id), order.ShippingAddress.PhoneNumber), font));
if (!String.IsNullOrEmpty(order.ShippingAddress.FaxNumber))
{
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Fax", lang.Id), order.ShippingAddress.FaxNumber), font));
}
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Address", lang.Id), order.ShippingAddress.Address1), font));
if (!String.IsNullOrEmpty(order.ShippingAddress.Address2))
{
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.Address2", lang.Id), order.ShippingAddress.Address2), font));
}
cell.AddElement(new Paragraph(" " + String.Format("{0}, {1} {2}", order.ShippingAddress.City, order.ShippingAddress.StateProvince != null ? order.ShippingAddress.StateProvince.GetLocalized(x => x.Name) : "", order.ShippingAddress.ZipPostalCode), font));
cell.AddElement(new Paragraph(" " + String.Format("{0}", order.ShippingAddress.Country != null ? order.ShippingAddress.Country.GetLocalized(x => x.Name) : ""), font));
cell.AddElement(new Paragraph(" "));
cell.AddElement(new Paragraph(" " + String.Format(_localizationService.GetResource("PDFInvoice.ShippingMethod", lang.Id), order.ShippingMethod), font));
cell.AddElement(new Paragraph());
addressTable.AddCell(cell);
}
else
{
cell = new PdfPCell(new Phrase(" "));
cell.Border = Rectangle.NO_BORDER;
addressTable.AddCell(cell);
}
doc.Add(addressTable);
doc.Add(new Paragraph(" "));
#endregion
#region Products
//products
doc.Add(new Paragraph(_localizationService.GetResource("PDFInvoice.Product(s)", lang.Id), titleFont));
doc.Add(new Paragraph(" "));
var orderProductVariants = _orderService.GetAllOrderProductVariants(order.Id, null, null, null, null, null, null);
var productsTable = new PdfPTable(4);
productsTable.WidthPercentage = 100f;
productsTable.SetWidths(new[] { 40, 20, 20, 20 });
//product name
cell = new PdfPCell(new Phrase(_localizationService.GetResource("PDFInvoice.ProductName", lang.Id), font));
cell.BackgroundColor = BaseColor.LIGHT_GRAY;
cell.HorizontalAlignment = Element.ALIGN_CENTER;
productsTable.AddCell(cell);
//price
cell = new PdfPCell(new Phrase(_localizationService.GetResource("PDFInvoice.ProductPrice", lang.Id), font));
cell.BackgroundColor = BaseColor.LIGHT_GRAY;
cell.HorizontalAlignment = Element.ALIGN_CENTER;
productsTable.AddCell(cell);
//qty
cell = new PdfPCell(new Phrase(_localizationService.GetResource("PDFInvoice.ProductQuantity", lang.Id), font));
cell.BackgroundColor = BaseColor.LIGHT_GRAY;
cell.HorizontalAlignment = Element.ALIGN_CENTER;
productsTable.AddCell(cell);
//total
cell = new PdfPCell(new Phrase(_localizationService.GetResource("PDFInvoice.ProductTotal", lang.Id), font));
cell.BackgroundColor = BaseColor.LIGHT_GRAY;
cell.HorizontalAlignment = Element.ALIGN_CENTER;
productsTable.AddCell(cell);
for (int i = 0; i < orderProductVariants.Count; i++)
{
var orderProductVariant = orderProductVariants[i];
var pv = orderProductVariant.ProductVariant;
//product name
string name = "";
if (!String.IsNullOrEmpty(pv.GetLocalized(x => x.Name)))
{
name = string.Format("{0} ({1})", pv.Product.GetLocalized(x => x.Name), pv.GetLocalized(x => x.Name));
}
else
{
name = pv.Product.GetLocalized(x => x.Name);
}
cell = new PdfPCell();
cell.AddElement(new Paragraph(name, font));
cell.HorizontalAlignment = Element.ALIGN_LEFT;
var attributesParagraph = new Paragraph(HtmlHelper.ConvertHtmlToPlainText(orderProductVariant.AttributeDescription, true), attributesFont);
cell.AddElement(attributesParagraph);
productsTable.AddCell(cell);
//price
string unitPrice = string.Empty;
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var opvUnitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderProductVariant.UnitPriceExclTax, order.CurrencyRate);
unitPrice = _priceFormatter.FormatPrice(opvUnitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var opvUnitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderProductVariant.UnitPriceInclTax, order.CurrencyRate);
unitPrice = _priceFormatter.FormatPrice(opvUnitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, true);
}
break;
}
cell = new PdfPCell(new Phrase(unitPrice, font));
cell.HorizontalAlignment = Element.ALIGN_LEFT;
productsTable.AddCell(cell);
//qty
cell = new PdfPCell(new Phrase(orderProductVariant.Quantity.ToString(), font));
cell.HorizontalAlignment = Element.ALIGN_LEFT;
productsTable.AddCell(cell);
//total
string subTotal = string.Empty;
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var opvPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderProductVariant.PriceExclTax, order.CurrencyRate);
subTotal = _priceFormatter.FormatPrice(opvPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var opvPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderProductVariant.PriceInclTax, order.CurrencyRate);
subTotal = _priceFormatter.FormatPrice(opvPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, true);
}
break;
}
cell = new PdfPCell(new Phrase(subTotal, font));
cell.HorizontalAlignment = Element.ALIGN_LEFT;
productsTable.AddCell(cell);
}
doc.Add(productsTable);
#endregion
#region Checkout attributes
if (!String.IsNullOrEmpty(order.CheckoutAttributeDescription))
{
doc.Add(new Paragraph(" "));
string attributes = HtmlHelper.ConvertHtmlToPlainText(order.CheckoutAttributeDescription, true);
var pCheckoutAttributes = new Paragraph(attributes, font);
pCheckoutAttributes.Alignment = Element.ALIGN_RIGHT;
doc.Add(pCheckoutAttributes);
doc.Add(new Paragraph(" "));
}
#endregion
#region Totals
//subtotal
doc.Add(new Paragraph(" "));
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
string orderSubtotalExclTaxStr = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, false);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Sub-Total", lang.Id), orderSubtotalExclTaxStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
case TaxDisplayType.IncludingTax:
{
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
string orderSubtotalInclTaxStr = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, true);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Sub-Total", lang.Id), orderSubtotalInclTaxStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
}
//discount (applied to order subtotal)
if (order.OrderSubTotalDiscountExclTax > decimal.Zero)
{
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
string orderSubTotalDiscountInCustomerCurrencyStr = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, false);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Discount", lang.Id), orderSubTotalDiscountInCustomerCurrencyStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
case TaxDisplayType.IncludingTax:
{
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
string orderSubTotalDiscountInCustomerCurrencyStr = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, true);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Discount", lang.Id), orderSubTotalDiscountInCustomerCurrencyStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
}
}
//shipping
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
string orderShippingExclTaxStr = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, false);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Shipping", lang.Id), orderShippingExclTaxStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
case TaxDisplayType.IncludingTax:
{
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
string orderShippingInclTaxStr = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, true);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Shipping", lang.Id), orderShippingInclTaxStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
}
}
//payment fee
if (order.PaymentMethodAdditionalFeeExclTax > decimal.Zero)
{
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
string paymentMethodAdditionalFeeExclTaxStr = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, false);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.PaymentMethodAdditionalFee", lang.Id), paymentMethodAdditionalFeeExclTaxStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
case TaxDisplayType.IncludingTax:
{
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
string paymentMethodAdditionalFeeInclTaxStr = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, lang, true);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.PaymentMethodAdditionalFee", lang.Id), paymentMethodAdditionalFeeInclTaxStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
break;
}
}
//tax
string taxStr = string.Empty;
var taxRates = new SortedDictionary <decimal, decimal>();
bool displayTax = true;
bool displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
}
else
{
if (order.OrderTax == 0 && _taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
taxRates = order.TaxRatesDictionary;
displayTaxRates = _taxSettings.DisplayTaxRates && taxRates.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
taxStr = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false);
}
}
if (displayTax)
{
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Tax", lang.Id), taxStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
if (displayTaxRates)
{
foreach (var item in taxRates)
{
string taxRate = String.Format(_localizationService.GetResource("PDFInvoice.TaxRate"), _priceFormatter.FormatTaxRate(item.Key));
//TODO pass languageId to _priceFormatter.FormatPrice
string taxValue = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(item.Value, order.CurrencyRate), true, false);
var p = new Paragraph(String.Format("{0} {1}", taxRate, taxValue), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
}
//discount (applied to order total)
if (order.OrderDiscount > decimal.Zero)
{
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
string orderDiscountInCustomerCurrencyStr = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false);
var p = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.Discount", lang.Id), orderDiscountInCustomerCurrencyStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
//gift cards
foreach (var gcuh in order.GiftCardUsageHistory)
{
string gcTitle = string.Format(_localizationService.GetResource("PDFInvoice.GiftCardInfo", lang.Id), gcuh.GiftCard.GiftCardCouponCode);
string gcAmountStr = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false);
var p = new Paragraph(String.Format("{0} {1}", gcTitle, gcAmountStr), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
//reward points
if (order.RedeemedRewardPointsEntry != null)
{
string rpTitle = string.Format(_localizationService.GetResource("PDFInvoice.RewardPoints", lang.Id), -order.RedeemedRewardPointsEntry.Points);
string rpAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false);
var p = new Paragraph(String.Format("{0} {1}", rpTitle, rpAmount), font);
p.Alignment = Element.ALIGN_RIGHT;
doc.Add(p);
}
//order total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
string orderTotalStr = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false);
var pTotal = new Paragraph(String.Format("{0} {1}", _localizationService.GetResource("PDFInvoice.OrderTotal", lang.Id), orderTotalStr), titleFont);
pTotal.Alignment = Element.ALIGN_RIGHT;
doc.Add(pTotal);
#endregion
#region Order notes
if (_pdfSettings.RenderOrderNotes)
{
var orderNotes = order.OrderNotes
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList();
if (orderNotes.Count > 0)
{
doc.Add(new Paragraph(_localizationService.GetResource("PDFInvoice.OrderNotes", lang.Id), titleFont));
doc.Add(new Paragraph(" "));
var notesTable = new PdfPTable(2);
notesTable.WidthPercentage = 100f;
notesTable.SetWidths(new[] { 30, 70 });
//created on
cell = new PdfPCell(new Phrase(_localizationService.GetResource("PDFInvoice.OrderNotes.CreatedOn", lang.Id), font));
cell.BackgroundColor = BaseColor.LIGHT_GRAY;
cell.HorizontalAlignment = Element.ALIGN_CENTER;
notesTable.AddCell(cell);
//note
cell = new PdfPCell(new Phrase(_localizationService.GetResource("PDFInvoice.OrderNotes.Note", lang.Id), font));
cell.BackgroundColor = BaseColor.LIGHT_GRAY;
cell.HorizontalAlignment = Element.ALIGN_CENTER;
notesTable.AddCell(cell);
foreach (var orderNote in orderNotes)
{
cell = new PdfPCell();
cell.AddElement(new Paragraph(_dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc).ToString(), font));
cell.HorizontalAlignment = Element.ALIGN_LEFT;
notesTable.AddCell(cell);
cell = new PdfPCell();
cell.AddElement(new Paragraph(HtmlHelper.ConvertHtmlToPlainText(HtmlHelper.FormatText(orderNote.Note, false, true, false, false, false, false), true), font));
cell.HorizontalAlignment = Element.ALIGN_LEFT;
notesTable.AddCell(cell);
}
doc.Add(notesTable);
}
}
#endregion
doc.Close();
}
protected SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
//return reasons
if (_orderSettings.ReturnRequestReasons != null)
{
foreach (var rrr in _orderSettings.ReturnRequestReasons)
{
model.AvailableReturnReasons.Add(new SelectListItem()
{
Text = rrr,
Value = rrr
});
}
}
//return actions
if (_orderSettings.ReturnRequestActions != null)
{
foreach (var rra in _orderSettings.ReturnRequestActions)
{
model.AvailableReturnActions.Add(new SelectListItem()
{
Text = rra,
Value = rra
});
}
}
//products
var orderProductVariants = _orderService.GetAllOrderProductVariants(order.Id, null, null, null, null, null, null);
foreach (var opv in orderProductVariants)
{
var opvModel = new SubmitReturnRequestModel.OrderProductVariantModel()
{
Id = opv.Id,
ProductId = opv.ProductVariant.ProductId,
ProductSeName = opv.ProductVariant.Product.GetSeName(),
AttributeInfo = opv.AttributeDescription,
Quantity = opv.Quantity
};
//product name
if (!String.IsNullOrEmpty(opv.ProductVariant.GetLocalized(x => x.Name)))
{
opvModel.ProductName = string.Format("{0} ({1})", opv.ProductVariant.Product.GetLocalized(x => x.Name), opv.ProductVariant.GetLocalized(x => x.Name));
}
else
{
opvModel.ProductName = opv.ProductVariant.Product.GetLocalized(x => x.Name);
}
model.Items.Add(opvModel);
//unit price
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var opvUnitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceExclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var opvUnitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceInclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
break;
}
}
return(model);
}
public static IEnumerable <ProductOverviewModel> PrepareProductOverviewModels(this Controller controller,
IWorkContext workContext,
IStoreContext storeContext,
ICategoryService categoryService,
IProductService productService,
ISpecificationAttributeService specificationAttributeService,
IPriceCalculationService priceCalculationService,
IPriceFormatter priceFormatter,
IPermissionService permissionService,
ILocalizationService localizationService,
ITaxService taxService,
ICurrencyService currencyService,
IPictureService pictureService,
IWebHelper webHelper,
ICacheManager cacheManager,
CatalogSettings catalogSettings,
MediaSettings mediaSettings,
IEnumerable <Product> products,
bool preparePriceModel = true, bool preparePictureModel = true,
int?productThumbPictureSize = null, bool prepareSpecificationAttributes = false,
bool forceRedirectionAfterAddingToCart = false)
{
if (products == null)
{
throw new ArgumentNullException("products");
}
var models = new List <ProductOverviewModel>();
foreach (var product in products)
{
var model = new ProductOverviewModel
{
Id = product.Id,
Name = product.GetLocalized(x => x.Name),
ShortDescription = product.GetLocalized(x => x.ShortDescription),
FullDescription = product.GetLocalized(x => x.FullDescription),
SeName = product.GetSeName(),
};
//price
if (preparePriceModel)
{
#region Prepare product price
var priceModel = new ProductOverviewModel.ProductPriceModel
{
ForceRedirectionAfterAddingToCart = forceRedirectionAfterAddingToCart
};
switch (product.ProductType)
{
case ProductType.GroupedProduct:
{
#region Grouped product
var associatedProducts = productService.GetAssociatedProducts(product.Id, storeContext.CurrentStore.Id);
switch (associatedProducts.Count)
{
case 0:
{
//no associated products
//priceModel.DisableBuyButton = true;
//priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//priceModel.AvailableForPreOrder = false;
}
break;
default:
{
//we have at least one associated product
//priceModel.DisableBuyButton = true;
//priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//priceModel.AvailableForPreOrder = false;
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
//find a minimum possible price
decimal?minPossiblePrice = null;
Product minPriceProduct = null;
foreach (var associatedProduct in associatedProducts)
{
//calculate for the maximum quantity (in case if we have tier prices)
var tmpPrice = priceCalculationService.GetFinalPrice(associatedProduct,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
if (!minPossiblePrice.HasValue || tmpPrice < minPossiblePrice.Value)
{
minPriceProduct = associatedProduct;
minPossiblePrice = tmpPrice;
}
}
if (minPriceProduct != null && !minPriceProduct.CustomerEntersPrice)
{
if (minPriceProduct.CallForPrice)
{
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else if (minPossiblePrice.HasValue)
{
//calculate prices
decimal taxRate;
decimal finalPriceBase = taxService.GetProductPrice(minPriceProduct, minPossiblePrice.Value, out taxRate);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
//Actually it's not possible (we presume that minimalPrice always has a value)
//We never should get here
Debug.WriteLine("Cannot calculate minPrice for product #{0}", product.Id);
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
}
break;
}
#endregion
}
break;
case ProductType.SimpleProduct:
default:
{
#region Simple product
//add to cart button
priceModel.DisableBuyButton = product.DisableBuyButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableShoppingCart) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//add to wishlist button
priceModel.DisableWishlistButton = product.DisableWishlistButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableWishlist) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//rental
priceModel.IsRental = product.IsRental;
//pre-order
if (product.AvailableForPreOrder)
{
priceModel.AvailableForPreOrder = !product.PreOrderAvailabilityStartDateTimeUtc.HasValue ||
product.PreOrderAvailabilityStartDateTimeUtc.Value >= DateTime.UtcNow;
priceModel.PreOrderAvailabilityStartDateTimeUtc = product.PreOrderAvailabilityStartDateTimeUtc;
}
//prices
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
if (!product.CustomerEntersPrice)
{
if (product.CallForPrice)
{
//call for price
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else
{
//prices
//calculate for the maximum quantity (in case if we have tier prices)
decimal minPossiblePrice = priceCalculationService.GetFinalPrice(product,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
decimal taxRate;
decimal oldPriceBase = taxService.GetProductPrice(product, product.OldPrice, out taxRate);
decimal finalPriceBase = taxService.GetProductPrice(product, minPossiblePrice, out taxRate);
decimal oldPrice = currencyService.ConvertFromPrimaryStoreCurrency(oldPriceBase, workContext.WorkingCurrency);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
//do we have tier prices configured?
var tierPrices = new List <TierPrice>();
if (product.HasTierPrices)
{
tierPrices.AddRange(product.TierPrices
.OrderBy(tp => tp.Quantity)
.ToList()
.FilterByStore(storeContext.CurrentStore.Id)
.FilterForCustomer(workContext.CurrentCustomer)
.RemoveDuplicatedQuantities());
}
//When there is just one tier (with qty 1),
//there are no actual savings in the list.
bool displayFromMessage = tierPrices.Count > 0 &&
!(tierPrices.Count == 1 && tierPrices[0].Quantity <= 1);
if (displayFromMessage)
{
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
if (finalPriceBase != oldPriceBase && oldPriceBase != decimal.Zero)
{
priceModel.OldPrice = priceFormatter.FormatPrice(oldPrice);
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
else
{
priceModel.OldPrice = null;
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
}
if (product.IsRental)
{
//rental product
priceModel.OldPrice = priceFormatter.FormatRentalProductPeriod(product, priceModel.OldPrice);
priceModel.Price = priceFormatter.FormatRentalProductPeriod(product, priceModel.Price);
}
//property for German market
//we display tax/shipping info only with "shipping enabled" for this product
//we also ensure this it's not free shipping
priceModel.DisplayTaxShippingInfo = catalogSettings.DisplayTaxShippingInfoProductBoxes &&
product.IsShipEnabled &&
!product.IsFreeShipping;
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
#endregion
}
break;
}
model.ProductPrice = priceModel;
#endregion
}
//picture
if (preparePictureModel)
{
#region Prepare product picture
//If a size has been set in the view, we use it in priority
int pictureSize = productThumbPictureSize.HasValue ? productThumbPictureSize.Value : mediaSettings.ProductThumbPictureSize;
//prepare picture model
var defaultProductPictureCacheKey = string.Format(ModelCacheEventConsumer.PRODUCT_DEFAULTPICTURE_MODEL_KEY, product.Id, pictureSize, true, workContext.WorkingLanguage.Id, webHelper.IsCurrentConnectionSecured(), storeContext.CurrentStore.Id);
model.DefaultPictureModel = cacheManager.Get(defaultProductPictureCacheKey, () =>
{
var picture = pictureService.GetPicturesByProductId(product.Id, 1).FirstOrDefault();
var pictureModel = new PictureModel
{
ImageUrl = pictureService.GetPictureUrl(picture, pictureSize),
FullSizeImageUrl = pictureService.GetPictureUrl(picture)
};
//"title" attribute
pictureModel.Title = (picture != null && !string.IsNullOrEmpty(picture.TitleAttribute)) ?
picture.TitleAttribute :
string.Format(localizationService.GetResource("Media.Product.ImageLinkTitleFormat"), model.Name);
//"alt" attribute
pictureModel.AlternateText = (picture != null && !string.IsNullOrEmpty(picture.AltAttribute)) ?
picture.AltAttribute :
string.Format(localizationService.GetResource("Media.Product.ImageAlternateTextFormat"), model.Name);
return(pictureModel);
});
#endregion
}
//specs
if (prepareSpecificationAttributes)
{
model.SpecificationAttributeModels = PrepareProductSpecificationModel(controller, workContext,
specificationAttributeService, cacheManager, product);
}
//reviews
model.ReviewOverviewModel = new ProductReviewOverviewModel
{
ProductId = product.Id,
RatingSum = product.ApprovedRatingSum,
TotalReviews = product.ApprovedTotalReviews,
AllowCustomerReviews = product.AllowCustomerReviews
};
models.Add(model);
}
return(models);
}
private string FormatPrice(decimal price)
{
return(_priceFormatter.FormatPrice(price, true, false));
}
public async Task <WishlistModel> Handle(GetWishlist request, CancellationToken cancellationToken)
{
var model = new WishlistModel {
EmailWishlistEnabled = _shoppingCartSettings.EmailWishlistEnabled,
IsEditable = request.IsEditable,
DisplayAddToCart = await _permissionService.Authorize(StandardPermissionProvider.EnableShoppingCart),
DisplayTaxShippingInfo = _catalogSettings.DisplayTaxShippingInfoWishlist
};
if (!request.Cart.Any())
{
return(model);
}
#region Simple properties
model.CustomerGuid = request.Customer.CustomerGuid;
model.CustomerFullname = request.Customer.GetFullName();
model.ShowProductImages = _shoppingCartSettings.ShowProductImagesOnWishList;
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
//cart warnings
var cartWarnings = await _shoppingCartService.GetShoppingCartWarnings(request.Cart, new List <Domain.Common.CustomAttribute>(), false);
foreach (var warning in cartWarnings)
{
model.Warnings.Add(warning);
}
#endregion
#region Cart items
foreach (var sci in request.Cart)
{
var product = await _productService.GetProductById(sci.ProductId);
if (!_aclService.Authorize(product))
{
continue;
}
var cartItemModel = new WishlistModel.ShoppingCartItemModel {
Id = sci.Id,
Sku = product.FormatSku(sci.Attributes, _productAttributeParser),
ProductId = product.Id,
ProductName = product.GetLocalized(x => x.Name, request.Language.Id),
ProductSeName = product.GetSeName(request.Language.Id),
Quantity = sci.Quantity,
AttributeInfo = await _productAttributeFormatter.FormatAttributes(product, sci.Attributes),
};
//allow editing?
//1. setting enabled?
//2. simple product?
//3. has attribute or gift card?
//4. visible individually?
cartItemModel.AllowItemEditing = _shoppingCartSettings.AllowCartItemEditing && product.ProductType == ProductType.SimpleProduct && (!String.IsNullOrEmpty(cartItemModel.AttributeInfo) || product.IsGiftCard) && product.VisibleIndividually;
//allowed quantities
var allowedQuantities = product.ParseAllowedQuantities();
foreach (var qty in allowedQuantities)
{
cartItemModel.AllowedQuantities.Add(new SelectListItem {
Text = qty.ToString(),
Value = qty.ToString(),
Selected = sci.Quantity == qty
});
}
//recurring info
if (product.IsRecurring)
{
cartItemModel.RecurringInfo = string.Format(_localizationService.GetResource("ShoppingCart.RecurringPeriod"), product.RecurringCycleLength, product.RecurringCyclePeriod.GetLocalizedEnum(_localizationService, request.Language.Id));
}
//unit prices
if (product.CallForPrice)
{
cartItemModel.UnitPrice = _localizationService.GetResource("Products.CallForPrice");
}
else
{
var productprice = await _taxService.GetProductPrice(product, (await _priceCalculationService.GetUnitPrice(sci, product)).unitprice);
decimal taxRate = productprice.taxRate;
cartItemModel.UnitPrice = _priceFormatter.FormatPrice(productprice.productprice);
}
//subtotal, discount
if (product.CallForPrice)
{
cartItemModel.SubTotal = _localizationService.GetResource("Products.CallForPrice");
}
else
{
//sub total
var subtotal = await _priceCalculationService.GetSubTotal(sci, product, true);
decimal shoppingCartItemDiscountBase = subtotal.discountAmount;
List <AppliedDiscount> scDiscounts = subtotal.appliedDiscounts;
var productprices = await _taxService.GetProductPrice(product, subtotal.subTotal);
decimal taxRate = productprices.taxRate;
cartItemModel.SubTotal = _priceFormatter.FormatPrice(productprices.productprice);
//display an applied discount amount
if (shoppingCartItemDiscountBase > decimal.Zero)
{
shoppingCartItemDiscountBase = (await _taxService.GetProductPrice(product, shoppingCartItemDiscountBase)).productprice;
if (shoppingCartItemDiscountBase > decimal.Zero)
{
cartItemModel.Discount = _priceFormatter.FormatPrice(shoppingCartItemDiscountBase);
}
}
}
//picture
if (_shoppingCartSettings.ShowProductImagesOnWishList)
{
cartItemModel.Picture = await PrepareCartItemPicture(request, product, sci.Attributes);
}
//item warnings
var itemWarnings = await _shoppingCartService.GetShoppingCartItemWarnings(request.Customer, sci, product, false);
foreach (var warning in itemWarnings)
{
cartItemModel.Warnings.Add(warning);
}
model.Items.Add(cartItemModel);
}
#endregion
return(model);
}
protected CheckoutConfirmModel PrepareConfirmOrderModel(IList <OrganizedShoppingCartItem> cart)
{
var model = new CheckoutConfirmModel();
//min order amount validation
bool minOrderTotalAmountOk = _orderProcessingService.ValidateMinOrderTotalAmount(cart);
if (!minOrderTotalAmountOk)
{
decimal minOrderTotalAmount = _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderTotalAmount, _workContext.WorkingCurrency);
model.MinOrderTotalWarning = string.Format(_localizationService.GetResource("Checkout.MinOrderTotalAmount"), _priceFormatter.FormatPrice(minOrderTotalAmount, true, false));
}
model.TermsOfServiceEnabled = _orderSettings.TermsOfServiceEnabled;
model.ShowEsdRevocationWaiverBox = _shoppingCartSettings.ShowEsdRevocationWaiverBox;
model.BypassPaymentMethodInfo = _paymentSettings.BypassPaymentMethodInfo;
return(model);
}
/// <summary>
/// Format base price (PAngV)
/// </summary>
/// <param name="product">Product</param>
/// <param name="productPrice">Product price (in primary currency). Pass null if you want to use a default produce price</param>
/// <param name="localizationService">Localization service</param>
/// <param name="measureService">Measure service</param>
/// <param name="currencyService">Currency service</param>
/// <param name="workContext">Work context</param>
/// <param name="priceFormatter">Price formatter</param>
/// <returns>Base price</returns>
public static string FormatBasePrice(this Product product, decimal?productPrice, ILocalizationService localizationService,
IMeasureService measureService, ICurrencyService currencyService,
IWorkContext workContext, IPriceFormatter priceFormatter)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
if (localizationService == null)
{
throw new ArgumentNullException(nameof(localizationService));
}
if (measureService == null)
{
throw new ArgumentNullException(nameof(measureService));
}
if (currencyService == null)
{
throw new ArgumentNullException(nameof(currencyService));
}
if (workContext == null)
{
throw new ArgumentNullException(nameof(workContext));
}
if (priceFormatter == null)
{
throw new ArgumentNullException(nameof(priceFormatter));
}
if (!product.BasepriceEnabled)
{
return(null);
}
var productAmount = product.BasepriceAmount;
//Amount in product cannot be 0
if (productAmount == 0)
{
return(null);
}
var referenceAmount = product.BasepriceBaseAmount;
var productUnit = measureService.GetMeasureWeightById(product.BasepriceUnitId);
//measure weight cannot be loaded
if (productUnit == null)
{
return(null);
}
var referenceUnit = measureService.GetMeasureWeightById(product.BasepriceBaseUnitId);
//measure weight cannot be loaded
if (referenceUnit == null)
{
return(null);
}
productPrice = productPrice.HasValue ? productPrice.Value : product.Price;
var basePrice = productPrice.Value /
//do not round. otherwise, it can cause issues
measureService.ConvertWeight(productAmount, productUnit, referenceUnit, false) *
referenceAmount;
var basePriceInCurrentCurrency = currencyService.ConvertFromPrimaryStoreCurrency(basePrice, workContext.WorkingCurrency);
var basePriceStr = priceFormatter.FormatPrice(basePriceInCurrentCurrency, true, false);
var result = string.Format(localizationService.GetResource("Products.BasePrice"),
basePriceStr, referenceAmount.ToString("G29"), referenceUnit.Name);
return(result);
}
/// <summary>
/// Format base price (PAngV)
/// </summary>
/// <param name="product">Product</param>
/// <param name="productPrice">Product price (in primary currency). Pass null if you want to use a default produce price</param>
/// <param name="localizationService">Localization service</param>
/// <param name="measureService">Measure service</param>
/// <param name="currencyService">Currency service</param>
/// <param name="workContext">Work context</param>
/// <param name="priceFormatter">Price formatter</param>
/// <returns>Base price</returns>
public static string FormatBasePrice(this Product product, decimal? productPrice, ILocalizationService localizationService,
IMeasureService measureService, ICurrencyService currencyService,
IWorkContext workContext, IPriceFormatter priceFormatter)
{
if (product == null)
throw new ArgumentNullException("product");
if (localizationService == null)
throw new ArgumentNullException("localizationService");
if (measureService == null)
throw new ArgumentNullException("measureService");
if (currencyService == null)
throw new ArgumentNullException("currencyService");
if (workContext == null)
throw new ArgumentNullException("workContext");
if (priceFormatter == null)
throw new ArgumentNullException("priceFormatter");
if (!product.BasepriceEnabled)
return null;
var productAmount = product.BasepriceAmount;
//Amount in product cannot be 0
if (productAmount == 0)
return null;
var referenceAmount = product.BasepriceBaseAmount;
var productUnit = measureService.GetMeasureWeightById(product.BasepriceUnitId);
//measure weight cannot be loaded
if (productUnit == null)
return null;
var referenceUnit = measureService.GetMeasureWeightById(product.BasepriceBaseUnitId);
//measure weight cannot be loaded
if (referenceUnit == null)
return null;
productPrice = productPrice.HasValue ? productPrice.Value : product.Price;
decimal basePrice = productPrice.Value /
//do not round. otherwise, it can cause issues
measureService.ConvertWeight(productAmount, productUnit, referenceUnit, false) *
referenceAmount;
decimal basePriceInCurrentCurrency = currencyService.ConvertFromPrimaryStoreCurrency(basePrice, workContext.WorkingCurrency);
string basePriceStr = priceFormatter.FormatPrice(basePriceInCurrentCurrency, true, false);
var result = string.Format(localizationService.GetResource("Products.BasePrice"),
basePriceStr, referenceAmount.ToString("G29"), referenceUnit.Name);
return result;
}
/// <summary>
/// Validates a product variant for standard properties
/// </summary>
/// <param name="customer">Customer</param>
/// <param name="shoppingCartType">Shopping cart type</param>
/// <param name="productVariant">Product variant</param>
/// <param name="selectedAttributes">Selected attributes</param>
/// <param name="customerEnteredPrice">Customer entered price</param>
/// <param name="quantity">Quantity</param>
/// <returns>Warnings</returns>
public virtual IList <string> GetStandardWarnings(Customer customer, ShoppingCartType shoppingCartType,
ProductVariant productVariant, string selectedAttributes, decimal customerEnteredPrice,
int quantity)
{
if (customer == null)
{
throw new ArgumentNullException("customer");
}
if (productVariant == null)
{
throw new ArgumentNullException("productVariant");
}
var warnings = new List <string>();
var product = productVariant.Product;
if (product == null)
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.CannotLoadProduct"), productVariant.ProductId));
return(warnings);
}
//deleted?
if (product.Deleted || productVariant.Deleted)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.ProductDeleted"));
return(warnings);
}
//published?
if (!product.Published || !productVariant.Published)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.ProductUnpublished"));
}
//ACL
if (!_aclService.Authorize(product, customer))
{
warnings.Add(_localizationService.GetResource("ShoppingCart.ProductUnpublished"));
}
//Store mapping
if (!_storeMappingService.Authorize(product, _storeContext.CurrentStore))
{
warnings.Add(_localizationService.GetResource("ShoppingCart.ProductUnpublished"));
}
//disabled "add to cart" button
if (shoppingCartType == ShoppingCartType.ShoppingCart && productVariant.DisableBuyButton)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.BuyingDisabled"));
}
//disabled "add to wishlist" button
if (shoppingCartType == ShoppingCartType.Wishlist && productVariant.DisableWishlistButton)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.WishlistDisabled"));
}
//call for price
if (shoppingCartType == ShoppingCartType.ShoppingCart && productVariant.CallForPrice)
{
warnings.Add(_localizationService.GetResource("Products.CallForPrice"));
}
//customer entered price
if (productVariant.CustomerEntersPrice)
{
if (customerEnteredPrice < productVariant.MinimumCustomerEnteredPrice ||
customerEnteredPrice > productVariant.MaximumCustomerEnteredPrice)
{
decimal minimumCustomerEnteredPrice = _currencyService.ConvertFromPrimaryStoreCurrency(productVariant.MinimumCustomerEnteredPrice, _workContext.WorkingCurrency);
decimal maximumCustomerEnteredPrice = _currencyService.ConvertFromPrimaryStoreCurrency(productVariant.MaximumCustomerEnteredPrice, _workContext.WorkingCurrency);
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.CustomerEnteredPrice.RangeError"),
_priceFormatter.FormatPrice(minimumCustomerEnteredPrice, false, false),
_priceFormatter.FormatPrice(maximumCustomerEnteredPrice, false, false)));
}
}
//quantity validation
var hasQtyWarnings = false;
if (quantity < productVariant.OrderMinimumQuantity)
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.MinimumQuantity"), productVariant.OrderMinimumQuantity));
hasQtyWarnings = true;
}
if (quantity > productVariant.OrderMaximumQuantity)
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.MaximumQuantity"), productVariant.OrderMaximumQuantity));
hasQtyWarnings = true;
}
var allowedQuantities = productVariant.ParseAllowedQuatities();
if (allowedQuantities.Length > 0 && !allowedQuantities.Contains(quantity))
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.AllowedQuantities"), string.Join(", ", allowedQuantities)));
}
var validateOutOfStock = shoppingCartType == ShoppingCartType.ShoppingCart || !_shoppingCartSettings.AllowOutOfStockItemsToBeAddedToWishlist;
if (validateOutOfStock && !hasQtyWarnings)
{
switch (productVariant.ManageInventoryMethod)
{
case ManageInventoryMethod.DontManageStock:
{
}
break;
case ManageInventoryMethod.ManageStock:
{
if ((BackorderMode)productVariant.BackorderMode == BackorderMode.NoBackorders)
{
if (productVariant.StockQuantity < quantity)
{
int maximumQuantityCanBeAdded = productVariant.StockQuantity;
if (maximumQuantityCanBeAdded <= 0)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.OutOfStock"));
}
else
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.QuantityExceedsStock"), maximumQuantityCanBeAdded));
}
}
}
}
break;
case ManageInventoryMethod.ManageStockByAttributes:
{
var combination = productVariant
.ProductVariantAttributeCombinations
.FirstOrDefault(x => _productAttributeParser.AreProductAttributesEqual(x.AttributesXml, selectedAttributes));
if (combination != null &&
!combination.AllowOutOfStockOrders &&
combination.StockQuantity < quantity)
{
int maximumQuantityCanBeAdded = combination.StockQuantity;
if (maximumQuantityCanBeAdded <= 0)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.OutOfStock"));
}
else
{
warnings.Add(string.Format(_localizationService.GetResource("ShoppingCart.QuantityExceedsStock"), maximumQuantityCanBeAdded));
}
}
}
break;
default:
break;
}
}
//availability dates
bool availableStartDateError = false;
if (productVariant.AvailableStartDateTimeUtc.HasValue)
{
DateTime now = DateTime.UtcNow;
DateTime availableStartDateTime = DateTime.SpecifyKind(productVariant.AvailableStartDateTimeUtc.Value, DateTimeKind.Utc);
if (availableStartDateTime.CompareTo(now) > 0)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.NotAvailable"));
availableStartDateError = true;
}
}
if (productVariant.AvailableEndDateTimeUtc.HasValue && !availableStartDateError)
{
DateTime now = DateTime.UtcNow;
DateTime availableEndDateTime = DateTime.SpecifyKind(productVariant.AvailableEndDateTimeUtc.Value, DateTimeKind.Utc);
if (availableEndDateTime.CompareTo(now) < 0)
{
warnings.Add(_localizationService.GetResource("ShoppingCart.NotAvailable"));
}
}
return(warnings);
}
/// <summary>
/// gets the base price
/// </summary>
/// <param name="product">Product</param>
/// <param name="localizationService">Localization service</param>
/// <param name="priceFormatter">Price formatter</param>
/// <param name="priceAdjustment">Price adjustment</param>
/// <returns>The base price</returns>
public static string GetBasePriceInfo(this Product product, ILocalizationService localizationService, IPriceFormatter priceFormatter,
decimal priceAdjustment = decimal.Zero)
{
if (product == null)
throw new ArgumentNullException("product");
if (localizationService == null)
throw new ArgumentNullException("localizationService");
if (product.BasePriceHasValue && product.BasePriceAmount != Decimal.Zero)
{
decimal price = decimal.Add(product.Price, priceAdjustment);
decimal basePriceValue = Convert.ToDecimal((price / product.BasePriceAmount) * product.BasePriceBaseAmount);
string basePrice = priceFormatter.FormatPrice(basePriceValue, false, false);
string unit = "{0} {1}".FormatWith(product.BasePriceBaseAmount, product.BasePriceMeasureUnit);
return localizationService.GetResource("Products.BasePriceInfo").FormatWith(basePrice, unit);
}
return "";
}
protected SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
string returnRequestReasons = _orderSettings.GetLocalized(x => x.ReturnRequestReasons, order.CustomerLanguageId, true, false);
string returnRequestActions = _orderSettings.GetLocalized(x => x.ReturnRequestActions, order.CustomerLanguageId, true, false);
//return reasons
foreach (var rrr in returnRequestReasons.SplitSafe(","))
{
model.AvailableReturnReasons.Add(new SelectListItem {
Text = rrr, Value = rrr
});
}
//return actions
foreach (var rra in returnRequestActions.SplitSafe(","))
{
model.AvailableReturnActions.Add(new SelectListItem {
Text = rra, Value = rra
});
}
//products
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
AttributeInfo = orderItem.AttributeDescription,
Quantity = orderItem.Quantity
};
orderItemModel.ProductUrl = _productUrlHelper.GetProductUrl(orderItemModel.ProductSeName, orderItem);
//unit price
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
break;
}
model.Items.Add(orderItemModel);
}
return(model);
}
protected CheckoutPaymentMethodModel PreparePaymentMethodModel(IList <OrganizedShoppingCartItem> cart)
{
var model = new CheckoutPaymentMethodModel();
//reward points
if (_rewardPointsSettings.Enabled && !cart.IsRecurring())
{
int rewardPointsBalance = _workContext.CurrentCustomer.GetRewardPointsBalance();
decimal rewardPointsAmountBase = _orderTotalCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
decimal rewardPointsAmount = _currencyService.ConvertFromPrimaryStoreCurrency(rewardPointsAmountBase, _workContext.WorkingCurrency);
if (rewardPointsAmount > decimal.Zero)
{
model.DisplayRewardPoints = true;
model.RewardPointsAmount = _priceFormatter.FormatPrice(rewardPointsAmount, true, false);
model.RewardPointsBalance = rewardPointsBalance;
}
}
var paymentTypes = new PaymentMethodType[] { PaymentMethodType.Standard, PaymentMethodType.Redirection, PaymentMethodType.StandardAndRedirection };
var boundPaymentMethods = _paymentService
.LoadActivePaymentMethods(_workContext.CurrentCustomer, cart, _storeContext.CurrentStore.Id, paymentTypes)
.ToList();
var allPaymentMethods = _paymentService.GetAllPaymentMethods();
foreach (var pm in boundPaymentMethods)
{
if (cart.IsRecurring() && pm.Value.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
var paymentMethod = allPaymentMethods.FirstOrDefault(x => x.PaymentMethodSystemName.IsCaseInsensitiveEqual(pm.Metadata.SystemName));
var pmModel = new CheckoutPaymentMethodModel.PaymentMethodModel
{
Name = _pluginMediator.GetLocalizedFriendlyName(pm.Metadata),
Description = _pluginMediator.GetLocalizedDescription(pm.Metadata),
PaymentMethodSystemName = pm.Metadata.SystemName,
PaymentInfoRoute = pm.Value.GetPaymentInfoRoute(),
RequiresInteraction = pm.Value.RequiresInteraction
};
if (paymentMethod != null)
{
pmModel.FullDescription = paymentMethod.GetLocalized(x => x.FullDescription, _workContext.WorkingLanguage.Id);
}
pmModel.BrandUrl = _pluginMediator.GetBrandImageUrl(pm.Metadata);
// payment method additional fee
decimal paymentMethodAdditionalFee = _paymentService.GetAdditionalHandlingFee(cart, pm.Metadata.SystemName);
decimal rateBase = _taxService.GetPaymentMethodAdditionalFee(paymentMethodAdditionalFee, _workContext.CurrentCustomer);
decimal rate = _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
if (rate != decimal.Zero)
{
pmModel.Fee = _priceFormatter.FormatPaymentMethodAdditionalFee(rate, true);
}
model.PaymentMethods.Add(pmModel);
}
// find a selected (previously) payment method
var selectedPaymentMethodSystemName = _workContext.CurrentCustomer.GetAttribute <string>(
SystemCustomerAttributeNames.SelectedPaymentMethod, _genericAttributeService, _storeContext.CurrentStore.Id);
bool selected = false;
if (selectedPaymentMethodSystemName.HasValue())
{
var paymentMethodToSelect = model.PaymentMethods.Find(pm => pm.PaymentMethodSystemName.IsCaseInsensitiveEqual(selectedPaymentMethodSystemName));
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
selected = true;
}
}
// if no option has been selected, let's do it for the first one
if (!selected)
{
var paymentMethodToSelect = model.PaymentMethods.FirstOrDefault();
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
}
}
return(model);
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="product">Product</param>
/// <param name="attributesXml">Attributes in XML format</param>
/// <param name="customer">Customer</param>
/// <param name="serapator">Serapator</param>
/// <param name="htmlEncode">A value indicating whether to encode (HTML) values</param>
/// <param name="renderPrices">A value indicating whether to render prices</param>
/// <param name="renderProductAttributes">A value indicating whether to render product attributes</param>
/// <param name="renderGiftCardAttributes">A value indicating whether to render gift card attributes</param>
/// <param name="allowHyperlinks">A value indicating whether to HTML hyperink tags could be rendered (if required)</param>
/// <returns>Attributes</returns>
public virtual string FormatAttributes(Product product, string attributesXml,
Customer customer, string serapator = "<br />", bool htmlEncode = true, bool renderPrices = true,
bool renderProductAttributes = true, bool renderGiftCardAttributes = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
//attributes
if (renderProductAttributes)
{
foreach (var attribute in _productAttributeParser.ParseProductAttributeMappings(attributesXml))
{
//attributes without values
if (!attribute.ShouldHaveValues())
{
foreach (var value in _productAttributeParser.ParseValues(attributesXml, attribute.Id))
{
var formattedAttribute = string.Empty;
if (attribute.AttributeControlType == AttributeControlType.MultilineTextbox)
{
//multiline textbox
var attributeName = attribute.ProductAttribute.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id);
//encode (if required)
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
//we never encode multiline textbox input
formattedAttribute = string.Format("{0}: {1}", attributeName, HtmlHelper.FormatText(value, false, true, false, false, false, false));
}
else if (attribute.AttributeControlType == AttributeControlType.FileUpload)
{
//file upload
Guid downloadGuid;
Guid.TryParse(value, out downloadGuid);
var download = _downloadService.GetDownloadByGuid(downloadGuid);
if (download != null)
{
var fileName = string.Format("{0}{1}", download.Filename ?? download.DownloadGuid.ToString(), download.Extension);
//encode (if required)
if (htmlEncode)
{
fileName = HttpUtility.HtmlEncode(fileName);
}
//TODO add a method for getting URL (use routing because it handles all SEO friendly URLs)
var attributeText = allowHyperlinks ? string.Format("<a href=\"{0}download/getfileupload/?downloadId={1}\" class=\"fileuploadattribute\">{2}</a>",
_webHelper.GetStoreLocation(false), download.DownloadGuid, fileName) : fileName;
var attributeName = attribute.ProductAttribute.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id);
//encode (if required)
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
formattedAttribute = string.Format("{0}: {1}", attributeName, attributeText);
}
}
else
{
//other attributes (textbox, datepicker)
formattedAttribute = string.Format("{0}: {1}", attribute.ProductAttribute.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id), value);
//encode (if required)
if (htmlEncode)
{
formattedAttribute = HttpUtility.HtmlEncode(formattedAttribute);
}
}
if (!string.IsNullOrEmpty(formattedAttribute))
{
if (result.Length > 0)
{
result.Append(serapator);
}
result.Append(formattedAttribute);
}
}
}
//product attribute values
else
{
foreach (var attributeValue in _productAttributeParser.ParseProductAttributeValues(attributesXml, attribute.Id))
{
var formattedAttribute = string.Format("{0}: {1}",
attribute.ProductAttribute.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id),
attributeValue.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id));
if (renderPrices)
{
decimal taxRate;
var attributeValuePriceAdjustment = _priceCalculationService.GetProductAttributeValuePriceAdjustment(attributeValue);
var priceAdjustmentBase = _taxService.GetProductPrice(product, attributeValuePriceAdjustment, customer, out taxRate);
var priceAdjustment = _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, _workContext.WorkingCurrency);
if (priceAdjustmentBase > 0)
{
formattedAttribute += string.Format(" [+{0}]", _priceFormatter.FormatPrice(priceAdjustment, false, false));
}
else if (priceAdjustmentBase < decimal.Zero)
{
formattedAttribute += string.Format(" [-{0}]", _priceFormatter.FormatPrice(-priceAdjustment, false, false));
}
}
//display quantity
if (_shoppingCartSettings.RenderAssociatedAttributeValueQuantity && attributeValue.AttributeValueType == AttributeValueType.AssociatedToProduct)
{
//render only when more than 1
if (attributeValue.Quantity > 1)
{
formattedAttribute += string.Format(_localizationService.GetResource("ProductAttributes.Quantity"), attributeValue.Quantity);
}
}
//encode (if required)
if (htmlEncode)
{
formattedAttribute = HttpUtility.HtmlEncode(formattedAttribute);
}
if (!string.IsNullOrEmpty(formattedAttribute))
{
if (result.Length > 0)
{
result.Append(serapator);
}
result.Append(formattedAttribute);
}
}
}
}
}
//gift cards
if (renderGiftCardAttributes)
{
if (product.IsGiftCard)
{
string giftCardRecipientName;
string giftCardRecipientEmail;
string giftCardSenderName;
string giftCardSenderEmail;
string giftCardMessage;
_productAttributeParser.GetGiftCardAttribute(attributesXml, out giftCardRecipientName, out giftCardRecipientEmail,
out giftCardSenderName, out giftCardSenderEmail, out giftCardMessage);
//sender
var giftCardFrom = product.GiftCardType == GiftCardType.Virtual ?
string.Format(_localizationService.GetResource("GiftCardAttribute.From.Virtual"), giftCardSenderName, giftCardSenderEmail) :
string.Format(_localizationService.GetResource("GiftCardAttribute.From.Physical"), giftCardSenderName);
//recipient
var giftCardFor = product.GiftCardType == GiftCardType.Virtual ?
string.Format(_localizationService.GetResource("GiftCardAttribute.For.Virtual"), giftCardRecipientName, giftCardRecipientEmail) :
string.Format(_localizationService.GetResource("GiftCardAttribute.For.Physical"), giftCardRecipientName);
//encode (if required)
if (htmlEncode)
{
giftCardFrom = HttpUtility.HtmlEncode(giftCardFrom);
giftCardFor = HttpUtility.HtmlEncode(giftCardFor);
}
if (!String.IsNullOrEmpty(result.ToString()))
{
result.Append(serapator);
}
result.Append(giftCardFrom);
result.Append(serapator);
result.Append(giftCardFor);
}
}
return(result.ToString());
}
protected DataSourceResult GetBestsellersBriefReportModel(int pageIndex,
int pageSize, int orderBy)
{
//a vendor should have access only to his products
string vendorId = "";
if (_workContext.CurrentVendor != null)
{
vendorId = _workContext.CurrentVendor.Id;
}
var items = _orderReportService.BestSellersReport(
vendorId: vendorId,
orderBy: orderBy,
pageIndex: pageIndex,
pageSize: pageSize,
showHidden: true);
var gridModel = new DataSourceResult
{
Data = items.Select(x =>
{
var m = new BestsellersReportLineModel
{
ProductId = x.ProductId,
TotalAmount = _priceFormatter.FormatPrice(x.TotalAmount, true, false),
TotalQuantity = x.TotalQuantity,
};
var product = _productService.GetProductById(x.ProductId);
if (product != null)
{
m.ProductName = product.Name;
}
return(m);
}),
Total = items.TotalCount
};
return(gridModel);
}
public virtual CustomerOrderListModel PrepareCustomerOrderListModel()
{
var model = new CustomerOrderListModel();
var orders = _orderService.SearchOrders(storeId: _storeContext.CurrentStore.Id,
customerId: _workContext.CurrentCustomer.Id);
foreach (var order in orders)
{
var orderModel = new CustomerOrderListModel.OrderDetailsModel
{
Id = order.Id,
CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc),
OrderStatusEnum = order.OrderStatus,
OrderStatus = order.OrderStatus.GetLocalizedEnum(_localizationService, _workContext),
PaymentStatus = order.PaymentStatus.GetLocalizedEnum(_localizationService, _workContext),
ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_localizationService, _workContext),
IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order)
};
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
orderModel.OrderTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
model.Orders.Add(orderModel);
}
var recurringPayments = _orderService.SearchRecurringPayments(_storeContext.CurrentStore.Id,
_workContext.CurrentCustomer.Id);
foreach (var recurringPayment in recurringPayments)
{
var recurringPaymentModel = new CustomerOrderListModel.RecurringOrderModel
{
Id = recurringPayment.Id,
StartDate = _dateTimeHelper.ConvertToUserTime(recurringPayment.StartDateUtc, DateTimeKind.Utc).ToString(),
CycleInfo = string.Format("{0} {1}", recurringPayment.CycleLength, recurringPayment.CyclePeriod.GetLocalizedEnum(_localizationService, _workContext)),
NextPayment = recurringPayment.NextPaymentDate.HasValue ? _dateTimeHelper.ConvertToUserTime(recurringPayment.NextPaymentDate.Value, DateTimeKind.Utc).ToString() : "",
TotalCycles = recurringPayment.TotalCycles,
CyclesRemaining = recurringPayment.CyclesRemaining,
InitialOrderId = recurringPayment.InitialOrder.Id,
CanCancel = _orderProcessingService.CanCancelRecurringPayment(_workContext.CurrentCustomer, recurringPayment),
CanRetryLastPayment = _orderProcessingService.CanRetryLastRecurringPayment(_workContext.CurrentCustomer, recurringPayment)
};
model.RecurringOrders.Add(recurringPaymentModel);
}
return(model);
}
/// <summary>
/// Prepare details to place an order. It also sets some properties to "processPaymentRequest"
/// </summary>
/// <param name="processPaymentRequest">Process payment request</param>
/// <returns>Details</returns>
protected override PlaceOrderContainter PreparePlaceOrderDetails(ProcessPaymentRequest processPaymentRequest)
{
var details = new PlaceOrderContainter();
//customer
details.Customer = _customerService.GetCustomerById(processPaymentRequest.CustomerId);
if (details.Customer == null)
{
throw new ArgumentException("Customer is not set");
}
//affiliate
var affiliate = _affiliateService.GetAffiliateById(details.Customer.AffiliateId);
if (affiliate != null && affiliate.Active && !affiliate.Deleted)
{
details.AffiliateId = affiliate.Id;
}
//check whether customer is guest
if (details.Customer.IsGuest() && !_orderSettings.AnonymousCheckoutAllowed)
{
throw new NopException("Anonymous checkout is not allowed");
}
//customer currency
var currencyTmp = _currencyService.GetCurrencyById(
details.Customer.GetAttribute <int>(SystemCustomerAttributeNames.CurrencyId, processPaymentRequest.StoreId));
var customerCurrency = (currencyTmp != null && currencyTmp.Published) ? currencyTmp : _workContext.WorkingCurrency;
var primaryStoreCurrency = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId);
details.CustomerCurrencyCode = customerCurrency.CurrencyCode;
//START PATCH
var coinServiceSettings = EngineContext.Current.ContainerManager.Resolve <CoinServiceSettings>();
string[] Cryptos;
if (coinServiceSettings.SupportedCoins != null)
{
Cryptos = coinServiceSettings.SupportedCoins.Split(',');
}
else
{
Cryptos = new string[0];
}
if (Cryptos.Contains(details.CustomerCurrencyCode))
{
details.CustomerCurrencyRate = CoinMarketCapHelper.GetCoinMarketCapRate(details.CustomerCurrencyCode) / primaryStoreCurrency.Rate;
}
else
{
details.CustomerCurrencyRate = customerCurrency.Rate / primaryStoreCurrency.Rate;
}
//END PATCH
//customer language
details.CustomerLanguage = _languageService.GetLanguageById(
details.Customer.GetAttribute <int>(SystemCustomerAttributeNames.LanguageId, processPaymentRequest.StoreId));
if (details.CustomerLanguage == null || !details.CustomerLanguage.Published)
{
details.CustomerLanguage = _workContext.WorkingLanguage;
}
//billing address
if (details.Customer.BillingAddress == null)
{
throw new NopException("Billing address is not provided");
}
if (!CommonHelper.IsValidEmail(details.Customer.BillingAddress.Email))
{
throw new NopException("Email is not valid");
}
details.BillingAddress = (Address)details.Customer.BillingAddress.Clone();
if (details.BillingAddress.Country != null && !details.BillingAddress.Country.AllowsBilling)
{
throw new NopException(string.Format("Country '{0}' is not allowed for billing", details.BillingAddress.Country.Name));
}
//checkout attributes
details.CheckoutAttributesXml = details.Customer.GetAttribute <string>(SystemCustomerAttributeNames.CheckoutAttributes, processPaymentRequest.StoreId);
details.CheckoutAttributeDescription = _checkoutAttributeFormatter.FormatAttributes(details.CheckoutAttributesXml, details.Customer);
//load shopping cart
details.Cart = details.Customer.ShoppingCartItems.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(processPaymentRequest.StoreId).ToList();
if (!details.Cart.Any())
{
throw new NopException("Cart is empty");
}
//validate the entire shopping cart
var warnings = _shoppingCartService.GetShoppingCartWarnings(details.Cart, details.CheckoutAttributesXml, true);
if (warnings.Any())
{
throw new NopException(warnings.Aggregate(string.Empty, (current, next) => string.Format("{0}{1};", current, next)));
}
//validate individual cart items
foreach (var sci in details.Cart)
{
var sciWarnings = _shoppingCartService.GetShoppingCartItemWarnings(details.Customer,
sci.ShoppingCartType, sci.Product, processPaymentRequest.StoreId, sci.AttributesXml,
sci.CustomerEnteredPrice, sci.RentalStartDateUtc, sci.RentalEndDateUtc, sci.Quantity, false);
if (sciWarnings.Any())
{
throw new NopException(sciWarnings.Aggregate(string.Empty, (current, next) => string.Format("{0}{1};", current, next)));
}
}
//min totals validation
if (!ValidateMinOrderSubtotalAmount(details.Cart))
{
var minOrderSubtotalAmount = _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderSubtotalAmount, _workContext.WorkingCurrency);
throw new NopException(string.Format(_localizationService.GetResource("Checkout.MinOrderSubtotalAmount"),
_priceFormatter.FormatPrice(minOrderSubtotalAmount, true, false)));
}
if (!ValidateMinOrderTotalAmount(details.Cart))
{
var minOrderTotalAmount = _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderTotalAmount, _workContext.WorkingCurrency);
throw new NopException(string.Format(_localizationService.GetResource("Checkout.MinOrderTotalAmount"),
_priceFormatter.FormatPrice(minOrderTotalAmount, true, false)));
}
//tax display type
if (_taxSettings.AllowCustomersToSelectTaxDisplayType)
{
details.CustomerTaxDisplayType = (TaxDisplayType)details.Customer.GetAttribute <int>(SystemCustomerAttributeNames.TaxDisplayTypeId, processPaymentRequest.StoreId);
}
else
{
details.CustomerTaxDisplayType = _taxSettings.TaxDisplayType;
}
//sub total (incl tax)
decimal orderSubTotalDiscountAmount;
List <DiscountForCaching> orderSubTotalAppliedDiscounts;
decimal subTotalWithoutDiscountBase;
decimal subTotalWithDiscountBase;
_orderTotalCalculationService.GetShoppingCartSubTotal(details.Cart, true, out orderSubTotalDiscountAmount,
out orderSubTotalAppliedDiscounts, out subTotalWithoutDiscountBase, out subTotalWithDiscountBase);
details.OrderSubTotalInclTax = subTotalWithoutDiscountBase;
details.OrderSubTotalDiscountInclTax = orderSubTotalDiscountAmount;
//discount history
foreach (var disc in orderSubTotalAppliedDiscounts)
{
if (!details.AppliedDiscounts.ContainsDiscount(disc))
{
details.AppliedDiscounts.Add(disc);
}
}
//sub total (excl tax)
_orderTotalCalculationService.GetShoppingCartSubTotal(details.Cart, false, out orderSubTotalDiscountAmount,
out orderSubTotalAppliedDiscounts, out subTotalWithoutDiscountBase, out subTotalWithDiscountBase);
details.OrderSubTotalExclTax = subTotalWithoutDiscountBase;
details.OrderSubTotalDiscountExclTax = orderSubTotalDiscountAmount;
//shipping info
if (details.Cart.RequiresShipping())
{
var pickupPoint = details.Customer.GetAttribute <PickupPoint>(SystemCustomerAttributeNames.SelectedPickupPoint, processPaymentRequest.StoreId);
if (_shippingSettings.AllowPickUpInStore && pickupPoint != null)
{
var country = _countryService.GetCountryByTwoLetterIsoCode(pickupPoint.CountryCode);
var state = _stateProvinceService.GetStateProvinceByAbbreviation(pickupPoint.StateAbbreviation);
details.PickUpInStore = true;
details.PickupAddress = new Address
{
Address1 = pickupPoint.Address,
City = pickupPoint.City,
Country = country,
StateProvince = state,
ZipPostalCode = pickupPoint.ZipPostalCode,
CreatedOnUtc = DateTime.UtcNow,
};
}
else
{
if (details.Customer.ShippingAddress == null)
{
throw new NopException("Shipping address is not provided");
}
if (!CommonHelper.IsValidEmail(details.Customer.ShippingAddress.Email))
{
throw new NopException("Email is not valid");
}
//clone shipping address
details.ShippingAddress = (Address)details.Customer.ShippingAddress.Clone();
if (details.ShippingAddress.Country != null && !details.ShippingAddress.Country.AllowsShipping)
{
throw new NopException(string.Format("Country '{0}' is not allowed for shipping", details.ShippingAddress.Country.Name));
}
}
var shippingOption = details.Customer.GetAttribute <ShippingOption>(SystemCustomerAttributeNames.SelectedShippingOption, processPaymentRequest.StoreId);
if (shippingOption != null)
{
details.ShippingMethodName = shippingOption.Name;
details.ShippingRateComputationMethodSystemName = shippingOption.ShippingRateComputationMethodSystemName;
}
details.ShippingStatus = ShippingStatus.NotYetShipped;
}
else
{
details.ShippingStatus = ShippingStatus.ShippingNotRequired;
}
//shipping total
decimal tax;
List <DiscountForCaching> shippingTotalDiscounts;
var orderShippingTotalInclTax = _orderTotalCalculationService.GetShoppingCartShippingTotal(details.Cart, true, out tax, out shippingTotalDiscounts);
var orderShippingTotalExclTax = _orderTotalCalculationService.GetShoppingCartShippingTotal(details.Cart, false);
if (!orderShippingTotalInclTax.HasValue || !orderShippingTotalExclTax.HasValue)
{
throw new NopException("Shipping total couldn't be calculated");
}
details.OrderShippingTotalInclTax = orderShippingTotalInclTax.Value;
details.OrderShippingTotalExclTax = orderShippingTotalExclTax.Value;
foreach (var disc in shippingTotalDiscounts)
{
if (!details.AppliedDiscounts.ContainsDiscount(disc))
{
details.AppliedDiscounts.Add(disc);
}
}
//payment total
var paymentAdditionalFee = _paymentService.GetAdditionalHandlingFee(details.Cart, processPaymentRequest.PaymentMethodSystemName);
details.PaymentAdditionalFeeInclTax = _taxService.GetPaymentMethodAdditionalFee(paymentAdditionalFee, true, details.Customer);
details.PaymentAdditionalFeeExclTax = _taxService.GetPaymentMethodAdditionalFee(paymentAdditionalFee, false, details.Customer);
//tax amount
SortedDictionary <decimal, decimal> taxRatesDictionary;
details.OrderTaxTotal = _orderTotalCalculationService.GetTaxTotal(details.Cart, out taxRatesDictionary);
//VAT number
var customerVatStatus = (VatNumberStatus)details.Customer.GetAttribute <int>(SystemCustomerAttributeNames.VatNumberStatusId);
if (_taxSettings.EuVatEnabled && customerVatStatus == VatNumberStatus.Valid)
{
details.VatNumber = details.Customer.GetAttribute <string>(SystemCustomerAttributeNames.VatNumber);
}
//tax rates
details.TaxRates = taxRatesDictionary.Aggregate(string.Empty, (current, next) =>
string.Format("{0}{1}:{2}; ", current, next.Key.ToString(CultureInfo.InvariantCulture), next.Value.ToString(CultureInfo.InvariantCulture)));
//order total (and applied discounts, gift cards, reward points)
List <AppliedGiftCard> appliedGiftCards;
List <DiscountForCaching> orderAppliedDiscounts;
decimal orderDiscountAmount;
int redeemedRewardPoints;
decimal redeemedRewardPointsAmount;
var orderTotal = _orderTotalCalculationService.GetShoppingCartTotal(details.Cart, out orderDiscountAmount,
out orderAppliedDiscounts, out appliedGiftCards, out redeemedRewardPoints, out redeemedRewardPointsAmount);
if (!orderTotal.HasValue)
{
throw new NopException("Order total couldn't be calculated");
}
details.OrderDiscountAmount = orderDiscountAmount;
details.RedeemedRewardPoints = redeemedRewardPoints;
details.RedeemedRewardPointsAmount = redeemedRewardPointsAmount;
details.AppliedGiftCards = appliedGiftCards;
details.OrderTotal = orderTotal.Value;
//discount history
foreach (var disc in orderAppliedDiscounts)
{
if (!details.AppliedDiscounts.ContainsDiscount(disc))
{
details.AppliedDiscounts.Add(disc);
}
}
processPaymentRequest.OrderTotal = details.OrderTotal;
//recurring or standard shopping cart?
details.IsRecurringShoppingCart = details.Cart.IsRecurring();
if (details.IsRecurringShoppingCart)
{
int recurringCycleLength;
RecurringProductCyclePeriod recurringCyclePeriod;
int recurringTotalCycles;
var recurringCyclesError = details.Cart.GetRecurringCycleInfo(_localizationService,
out recurringCycleLength, out recurringCyclePeriod, out recurringTotalCycles);
if (!string.IsNullOrEmpty(recurringCyclesError))
{
throw new NopException(recurringCyclesError);
}
processPaymentRequest.RecurringCycleLength = recurringCycleLength;
processPaymentRequest.RecurringCyclePeriod = recurringCyclePeriod;
processPaymentRequest.RecurringTotalCycles = recurringTotalCycles;
}
return(details);
}
private OrderDetailsModel.OrderItemModel PrepareOrderItemModel(
Order order,
OrderItem orderItem,
CatalogSettings catalogSettings,
ShoppingCartSettings shoppingCartSettings,
MediaSettings mediaSettings)
{
var language = _services.WorkContext.WorkingLanguage;
orderItem.Product.MergeWithCombination(orderItem.AttributesXml);
var model = new OrderDetailsModel.OrderItemModel
{
Id = orderItem.Id,
Sku = orderItem.Product.Sku,
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
ProductType = orderItem.Product.ProductType,
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription
};
var quantityUnit = _quantityUnitService.GetQuantityUnitById(orderItem.Product.QuantityUnitId);
model.QuantityUnit = (quantityUnit == null ? "" : quantityUnit.GetLocalized(x => x.Name));
if (orderItem.Product.ProductType == ProductType.BundledProduct && orderItem.BundleData.HasValue())
{
var bundleData = orderItem.GetBundleData();
model.BundlePerItemPricing = orderItem.Product.BundlePerItemPricing;
model.BundlePerItemShoppingCart = bundleData.Any(x => x.PerItemShoppingCart);
foreach (var bundleItem in bundleData)
{
var bundleItemModel = new OrderDetailsModel.BundleItemModel
{
Sku = bundleItem.Sku,
ProductName = bundleItem.ProductName,
ProductSeName = bundleItem.ProductSeName,
VisibleIndividually = bundleItem.VisibleIndividually,
Quantity = bundleItem.Quantity,
DisplayOrder = bundleItem.DisplayOrder,
AttributeInfo = bundleItem.AttributesInfo
};
bundleItemModel.ProductUrl = _productUrlHelper.GetProductUrl(bundleItem.ProductId, bundleItemModel.ProductSeName, bundleItem.AttributesXml);
if (model.BundlePerItemShoppingCart)
{
decimal priceWithDiscount = _currencyService.ConvertCurrency(bundleItem.PriceWithDiscount, order.CurrencyRate);
bundleItemModel.PriceWithDiscount = _priceFormatter.FormatPrice(priceWithDiscount, true, order.CustomerCurrencyCode, language, false, false);
}
model.BundleItems.Add(bundleItemModel);
}
}
// Unit price, subtotal
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
model.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
model.SubTotal = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
model.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true, false);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
model.SubTotal = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true, false);
}
break;
}
model.ProductUrl = _productUrlHelper.GetProductUrl(model.ProductSeName, orderItem);
if (shoppingCartSettings.ShowProductImagesOnShoppingCart)
{
model.Picture = PrepareOrderItemPictureModel(
orderItem.Product,
mediaSettings.CartThumbPictureSize,
model.ProductName,
orderItem.AttributesXml,
catalogSettings);
}
return(model);
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="attributes">Attributes</param>
/// <param name="customer">Customer</param>
/// <param name="serapator">Serapator</param>
/// <param name="htmlEncode">A value indicating whether to encode (HTML) values</param>
/// <param name="renderPrices">A value indicating whether to render prices</param>
/// <param name="allowHyperlinks">A value indicating whether to HTML hyperink tags could be rendered (if required)</param>
/// <returns>Attributes</returns>
public string FormatAttributes(string attributes,
Customer customer,
string serapator = "<br />",
bool htmlEncode = true,
bool renderPrices = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
var caCollection = _checkoutAttributeParser.ParseCheckoutAttributes(attributes);
for (int i = 0; i < caCollection.Count; i++)
{
var ca = caCollection[i];
var valuesStr = _checkoutAttributeParser.ParseValues(attributes, ca.Id);
for (int j = 0; j < valuesStr.Count; j++)
{
string valueStr = valuesStr[j];
string caAttribute = "";
if (!ca.ShouldHaveValues())
{
//no values
if (ca.AttributeControlType == AttributeControlType.MultilineTextbox)
{
//multiline textbox
var attributeName = ca.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id);
//encode (if required)
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
caAttribute = string.Format("{0}: {1}", attributeName, HtmlHelper.FormatText(valueStr, false, true, false, false, false, false));
//we never encode multiline textbox input
}
else if (ca.AttributeControlType == AttributeControlType.FileUpload)
{
//file upload
var download = _downloadService.GetDownloadByGuid(Guid.Parse(valueStr));
if (download != null)
{
//TODO add a method for getting URL (use routing because it handles all SEO friendly URLs)
string attributeText = "";
var fileName = string.Format("{0}{1}",
download.Filename ?? download.DownloadGuid.ToString(),
download.Extension);
//encode (if required)
if (htmlEncode)
{
fileName = HttpUtility.HtmlEncode(fileName);
}
if (allowHyperlinks)
{
//hyperlinks are allowed
var downloadLink = string.Format("{0}download/getfileupload/?downloadId={1}", _webHelper.GetStoreLocation(false), download.DownloadGuid);
attributeText = string.Format("<a href=\"{0}\" class=\"fileuploadattribute\">{1}</a>", downloadLink, fileName);
}
else
{
//hyperlinks aren't allowed
attributeText = fileName;
}
var attributeName = ca.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id);
//encode (if required)
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
caAttribute = string.Format("{0}: {1}", attributeName, attributeText);
}
}
else
{
//other attributes (textbox, datepicker)
caAttribute = string.Format("{0}: {1}", ca.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id), valueStr);
//encode (if required)
if (htmlEncode)
{
caAttribute = HttpUtility.HtmlEncode(caAttribute);
}
}
}
else
{
int caId = 0;
if (int.TryParse(valueStr, out caId))
{
var caValue = _checkoutAttributeService.GetCheckoutAttributeValueById(caId);
if (caValue != null)
{
caAttribute = string.Format("{0}: {1}", ca.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id), caValue.GetLocalized(a => a.Name, _workContext.WorkingLanguage.Id));
if (renderPrices)
{
decimal priceAdjustmentBase = _taxService.GetCheckoutAttributePrice(caValue, customer);
decimal priceAdjustment = _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, _workContext.WorkingCurrency);
if (priceAdjustmentBase > 0)
{
string priceAdjustmentStr = _priceFormatter.FormatPrice(priceAdjustment);
caAttribute += string.Format(" [+{0}]", priceAdjustmentStr);
}
}
}
//encode (if required)
if (htmlEncode)
{
caAttribute = HttpUtility.HtmlEncode(caAttribute);
}
}
}
if (!String.IsNullOrEmpty(caAttribute))
{
if (i != 0 || j != 0)
{
result.Append(serapator);
}
result.Append(caAttribute);
}
}
}
return(result.ToString());
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="product">Product</param>
/// <param name="attributesXml">Attributes in XML format</param>
/// <param name="customer">Customer</param>
/// <param name="separator">Separator</param>
/// <param name="htmlEncode">A value indicating whether to encode (HTML) values</param>
/// <param name="renderPrices">A value indicating whether to render prices</param>
/// <param name="renderProductAttributes">A value indicating whether to render product attributes</param>
/// <param name="renderGiftCardAttributes">A value indicating whether to render gift card attributes</param>
/// <param name="allowHyperlinks">A value indicating whether to HTML hyperink tags could be rendered (if required)</param>
/// <returns>Attributes</returns>
public virtual string FormatAttributes(Product product, string attributesXml,
Customer customer, string separator = "<br />", bool htmlEncode = true, bool renderPrices = true,
bool renderProductAttributes = true, bool renderGiftCardAttributes = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
//attributes
if (renderProductAttributes)
{
foreach (var attribute in _productAttributeParser.ParseProductAttributeMappings(attributesXml))
{
var productAttrubute = _productAttributeService.GetProductAttributeById(attribute.ProductAttributeId);
var attributeName = _localizationService.GetLocalized(productAttrubute, a => a.Name, _workContext.WorkingLanguage.Id);
//attributes without values
if (!attribute.ShouldHaveValues())
{
foreach (var value in _productAttributeParser.ParseValues(attributesXml, attribute.Id))
{
var formattedAttribute = string.Empty;
if (attribute.AttributeControlType == AttributeControlType.MultilineTextbox)
{
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
//we never encode multiline textbox input
formattedAttribute = $"{attributeName}: {HtmlHelper.FormatText(value, false, true, false, false, false, false)}";
}
else if (attribute.AttributeControlType == AttributeControlType.FileUpload)
{
//file upload
Guid.TryParse(value, out var downloadGuid);
var download = _downloadService.GetDownloadByGuid(downloadGuid);
if (download != null)
{
var fileName = $"{download.Filename ?? download.DownloadGuid.ToString()}{download.Extension}";
//encode (if required)
if (htmlEncode)
{
fileName = WebUtility.HtmlEncode(fileName);
}
var attributeText = allowHyperlinks ? $"<a href=\"{_webHelper.GetStoreLocation(false)}download/getfileupload/?downloadId={download.DownloadGuid}\" class=\"fileuploadattribute\">{fileName}</a>"
: fileName;
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
formattedAttribute = $"{attributeName}: {attributeText}";
}
}
else
{
//other attributes (textbox, datepicker)
formattedAttribute = $"{attributeName}: {value}";
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
}
if (string.IsNullOrEmpty(formattedAttribute))
{
continue;
}
if (result.Length > 0)
{
result.Append(separator);
}
result.Append(formattedAttribute);
}
}
//product attribute values
else
{
foreach (var attributeValue in _productAttributeParser.ParseProductAttributeValues(attributesXml, attribute.Id))
{
var formattedAttribute = $"{attributeName}: {_localizationService.GetLocalized(attributeValue, a => a.Name, _workContext.WorkingLanguage.Id)}";
if (renderPrices)
{
if (attributeValue.PriceAdjustmentUsePercentage)
{
if (attributeValue.PriceAdjustment > decimal.Zero)
{
formattedAttribute += string.Format(
_localizationService.GetResource("FormattedAttributes.PriceAdjustment"),
"+", attributeValue.PriceAdjustment.ToString("G29"), "%");
}
else if (attributeValue.PriceAdjustment < decimal.Zero)
{
formattedAttribute += string.Format(
_localizationService.GetResource("FormattedAttributes.PriceAdjustment"),
string.Empty, attributeValue.PriceAdjustment.ToString("G29"), "%");
}
}
else
{
var attributeValuePriceAdjustment = _priceCalculationService.GetProductAttributeValuePriceAdjustment(product, attributeValue, customer);
var priceAdjustmentBase = _taxService.GetProductPrice(product, attributeValuePriceAdjustment, customer, out var _);
var priceAdjustment = _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, _workContext.WorkingCurrency);
if (priceAdjustmentBase > decimal.Zero)
{
formattedAttribute += string.Format(
_localizationService.GetResource("FormattedAttributes.PriceAdjustment"),
"+", _priceFormatter.FormatPrice(priceAdjustment, false, false), string.Empty);
}
else if (priceAdjustmentBase < decimal.Zero)
{
formattedAttribute += string.Format(
_localizationService.GetResource("FormattedAttributes.PriceAdjustment"),
"-", _priceFormatter.FormatPrice(-priceAdjustment, false, false), string.Empty);
}
}
}
//display quantity
if (_shoppingCartSettings.RenderAssociatedAttributeValueQuantity && attributeValue.AttributeValueType == AttributeValueType.AssociatedToProduct)
{
//render only when more than 1
if (attributeValue.Quantity > 1)
{
formattedAttribute += string.Format(_localizationService.GetResource("ProductAttributes.Quantity"), attributeValue.Quantity);
}
}
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
if (string.IsNullOrEmpty(formattedAttribute))
{
continue;
}
if (result.Length > 0)
{
result.Append(separator);
}
result.Append(formattedAttribute);
}
}
}
}
//gift cards
if (!renderGiftCardAttributes)
{
return(result.ToString());
}
if (!product.IsGiftCard)
{
return(result.ToString());
}
_productAttributeParser.GetGiftCardAttribute(attributesXml, out var giftCardRecipientName, out var giftCardRecipientEmail, out var giftCardSenderName, out var giftCardSenderEmail, out var _);
//sender
var giftCardFrom = product.GiftCardType == GiftCardType.Virtual ?
string.Format(_localizationService.GetResource("GiftCardAttribute.From.Virtual"), giftCardSenderName, giftCardSenderEmail) :
string.Format(_localizationService.GetResource("GiftCardAttribute.From.Physical"), giftCardSenderName);
//recipient
var giftCardFor = product.GiftCardType == GiftCardType.Virtual ?
string.Format(_localizationService.GetResource("GiftCardAttribute.For.Virtual"), giftCardRecipientName, giftCardRecipientEmail) :
string.Format(_localizationService.GetResource("GiftCardAttribute.For.Physical"), giftCardRecipientName);
//encode (if required)
if (htmlEncode)
{
giftCardFrom = WebUtility.HtmlEncode(giftCardFrom);
giftCardFor = WebUtility.HtmlEncode(giftCardFor);
}
if (!string.IsNullOrEmpty(result.ToString()))
{
result.Append(separator);
}
result.Append(giftCardFrom);
result.Append(separator);
result.Append(giftCardFor);
return(result.ToString());
}
/// <summary>
/// Prepare payment method model
/// </summary>
/// <param name="cart">Cart</param>
/// <param name="filterByCountryId">Filter by country identifier</param>
/// <returns>Payment method model</returns>
public virtual CheckoutPaymentMethodModel PreparePaymentMethodModel(IList <ShoppingCartItem> cart, int filterByCountryId)
{
var model = new CheckoutPaymentMethodModel();
//reward points
if (_rewardPointsSettings.Enabled && !_shoppingCartService.ShoppingCartIsRecurring(cart))
{
var rewardPointsBalance = _rewardPointService.GetRewardPointsBalance(_workContext.CurrentCustomer.Id, _storeContext.CurrentStore.Id);
rewardPointsBalance = _rewardPointService.GetReducedPointsBalance(rewardPointsBalance);
var rewardPointsAmountBase = _orderTotalCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
var rewardPointsAmount = _currencyService.ConvertFromPrimaryStoreCurrency(rewardPointsAmountBase, _workContext.WorkingCurrency);
if (rewardPointsAmount > decimal.Zero &&
_orderTotalCalculationService.CheckMinimumRewardPointsToUseRequirement(rewardPointsBalance))
{
model.DisplayRewardPoints = true;
model.RewardPointsAmount = _priceFormatter.FormatPrice(rewardPointsAmount, true, false);
model.RewardPointsBalance = rewardPointsBalance;
//are points enough to pay for entire order? like if this option (to use them) was selected
model.RewardPointsEnoughToPayForOrder = !_orderProcessingService.IsPaymentWorkflowRequired(cart, true);
}
}
//filter by country
var paymentMethods = _paymentService
.LoadActivePaymentMethods(_workContext.CurrentCustomer, _storeContext.CurrentStore.Id, filterByCountryId)
.Where(pm => pm.PaymentMethodType == PaymentMethodType.Standard || pm.PaymentMethodType == PaymentMethodType.Redirection)
.Where(pm => !pm.HidePaymentMethod(cart))
.ToList();
foreach (var pm in paymentMethods)
{
if (_shoppingCartService.ShoppingCartIsRecurring(cart) && pm.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
var pmModel = new CheckoutPaymentMethodModel.PaymentMethodModel
{
Name = _localizationService.GetLocalizedFriendlyName(pm, _workContext.WorkingLanguage.Id),
Description = _paymentSettings.ShowPaymentMethodDescriptions ? pm.PaymentMethodDescription : string.Empty,
PaymentMethodSystemName = pm.PluginDescriptor.SystemName,
LogoUrl = PluginManager.GetLogoUrl(pm.PluginDescriptor)
};
//payment method additional fee
var paymentMethodAdditionalFee = _paymentService.GetAdditionalHandlingFee(cart, pm.PluginDescriptor.SystemName);
var rateBase = _taxService.GetPaymentMethodAdditionalFee(paymentMethodAdditionalFee, _workContext.CurrentCustomer);
var rate = _currencyService.ConvertFromPrimaryStoreCurrency(rateBase, _workContext.WorkingCurrency);
if (rate > decimal.Zero)
{
pmModel.Fee = _priceFormatter.FormatPaymentMethodAdditionalFee(rate, true);
}
model.PaymentMethods.Add(pmModel);
}
//find a selected (previously) payment method
var selectedPaymentMethodSystemName = _genericAttributeService.GetAttribute <string>(_workContext.CurrentCustomer,
NopCustomerDefaults.SelectedPaymentMethodAttribute, _storeContext.CurrentStore.Id);
if (!string.IsNullOrEmpty(selectedPaymentMethodSystemName))
{
var paymentMethodToSelect = model.PaymentMethods.ToList()
.Find(pm => pm.PaymentMethodSystemName.Equals(selectedPaymentMethodSystemName, StringComparison.InvariantCultureIgnoreCase));
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
}
}
//if no option has been selected, let's do it for the first one
if (model.PaymentMethods.FirstOrDefault(so => so.Selected) == null)
{
var paymentMethodToSelect = model.PaymentMethods.FirstOrDefault();
if (paymentMethodToSelect != null)
{
paymentMethodToSelect.Selected = true;
}
}
return(model);
}
private async Task PrepareSimpleProperties(ShoppingCartModel model, GetShoppingCart request)
{
#region Simple properties
model.IsEditable = request.IsEditable;
model.IsAllowOnHold = _shoppingCartSettings.AllowOnHoldCart;
model.TermsOfServicePopup = _commonSettings.PopupForTermsOfServiceLinks;
model.ShowProductImages = _shoppingCartSettings.ShowProductImagesOnShoppingCart;
model.ShowSku = _catalogSettings.ShowSkuOnProductDetailsPage;
model.IsGuest = request.Customer.IsGuest();
model.ShowCheckoutAsGuestButton = model.IsGuest && _orderSettings.AnonymousCheckoutAllowed;
var checkoutAttributesXml = request.Customer.GetAttributeFromEntity <string>(SystemCustomerAttributeNames.CheckoutAttributes, request.Store.Id);
model.CheckoutAttributeInfo = await _checkoutAttributeFormatter.FormatAttributes(checkoutAttributesXml, request.Customer);
if (!request.Cart.Where(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart || x.ShoppingCartType == ShoppingCartType.Auctions).ToList().Any())
{
model.MinOrderSubtotalWarning = _localizationService.GetResource("Checkout.MinOrderOneProduct");
}
else
{
bool minOrderSubtotalAmountOk = await _orderProcessingService.ValidateMinOrderSubtotalAmount(request.Cart.Where(x => x.ShoppingCartType == ShoppingCartType.ShoppingCart || x.ShoppingCartType == ShoppingCartType.Auctions).ToList());
if (!minOrderSubtotalAmountOk)
{
decimal minOrderSubtotalAmount = await _currencyService.ConvertFromPrimaryStoreCurrency(_orderSettings.MinOrderSubtotalAmount, request.Currency);
model.MinOrderSubtotalWarning = string.Format(_localizationService.GetResource("Checkout.MinOrderSubtotalAmount"), _priceFormatter.FormatPrice(minOrderSubtotalAmount, true, false));
}
}
model.TermsOfServiceOnShoppingCartPage = _orderSettings.TermsOfServiceOnShoppingCartPage;
model.TermsOfServiceOnOrderConfirmPage = _orderSettings.TermsOfServiceOnOrderConfirmPage;
model.DisplayTaxShippingInfo = _catalogSettings.DisplayTaxShippingInfoShoppingCart;
//gift card and gift card boxes
model.DiscountBox.Display = _shoppingCartSettings.ShowDiscountBox;
var discountCouponCodes = request.Customer.ParseAppliedCouponCodes(SystemCustomerAttributeNames.DiscountCoupons);
foreach (var couponCode in discountCouponCodes)
{
var discount = await _discountService.GetDiscountByCouponCode(couponCode);
if (discount != null &&
discount.RequiresCouponCode &&
(await _discountService.ValidateDiscount(discount, request.Customer)).IsValid)
{
model.DiscountBox.AppliedDiscountsWithCodes.Add(new ShoppingCartModel.DiscountBoxModel.DiscountInfoModel()
{
Id = discount.Id,
CouponCode = couponCode
});
}
}
model.GiftCardBox.Display = _shoppingCartSettings.ShowGiftCardBox;
//cart warnings
var cartWarnings = await _shoppingCartService.GetShoppingCartWarnings(request.Cart, checkoutAttributesXml, request.ValidateCheckoutAttributes);
foreach (var warning in cartWarnings)
{
model.Warnings.Add(warning);
}
#endregion
}
/// <summary>
/// Load price range filters
/// </summary>
/// <param name="priceRangeStr">Price range in string format</param>
/// <param name="webHelper">Web helper</param>
/// <param name="priceFormatter">Price formatter</param>
public virtual void LoadPriceRangeFilters(string priceRangeStr, IWebHelper webHelper, IPriceFormatter priceFormatter)
{
var priceRangeList = GetPriceRangeList(priceRangeStr);
if (priceRangeList.Any())
{
Enabled = true;
var selectedPriceRange = GetSelectedPriceRange(webHelper, priceRangeStr);
Items = priceRangeList.ToList().Select(x =>
{
//from&to
var item = new PriceRangeFilterItem();
if (x.From.HasValue)
{
item.From = priceFormatter.FormatPrice(x.From.Value, true, false);
}
if (x.To.HasValue)
{
item.To = priceFormatter.FormatPrice(x.To.Value, true, false);
}
var fromQuery = string.Empty;
if (x.From.HasValue)
{
fromQuery = x.From.Value.ToString(new CultureInfo("en-US"));
}
var toQuery = string.Empty;
if (x.To.HasValue)
{
toQuery = x.To.Value.ToString(new CultureInfo("en-US"));
}
//is selected?
if (selectedPriceRange != null &&
selectedPriceRange.From == x.From &&
selectedPriceRange.To == x.To)
{
item.Selected = true;
}
//filter URL
var url = webHelper.ModifyQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM, $"{fromQuery}-{toQuery}");
url = ExcludeQueryStringParams(url, webHelper);
item.FilterUrl = url;
return(item);
}).ToList();
if (selectedPriceRange != null)
{
//remove filter URL
var url = webHelper.RemoveQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM);
url = ExcludeQueryStringParams(url, webHelper);
RemoveFilterUrl = url;
}
}
else
{
Enabled = false;
}
}
/// <summary>
/// Formats attributes
/// </summary>
/// <param name="attributesXml">Attributes in XML format</param>
/// <param name="customer">Customer</param>
/// <param name="separator">Separator</param>
/// <param name="htmlEncode">A value indicating whether to encode (HTML) values</param>
/// <param name="renderPrices">A value indicating whether to render prices</param>
/// <param name="allowHyperlinks">A value indicating whether to HTML hyperlink tags could be rendered (if required)</param>
/// <returns>Attributes</returns>
public virtual string FormatAttributes(string attributesXml,
Customer customer,
string separator = "<br />",
bool htmlEncode = true,
bool renderPrices = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
var attributes = _checkoutAttributeParser.ParseCheckoutAttributes(attributesXml);
for (var i = 0; i < attributes.Count; i++)
{
var attribute = attributes[i];
var valuesStr = _checkoutAttributeParser.ParseValues(attributesXml, attribute.Id);
for (var j = 0; j < valuesStr.Count; j++)
{
var valueStr = valuesStr[j];
var formattedAttribute = string.Empty;
if (!attribute.ShouldHaveValues())
{
//no values
if (attribute.AttributeControlType == AttributeControlType.MultilineTextbox)
{
//multiline textbox
var attributeName = _localizationService.GetLocalized(attribute, a => a.Name, _workContext.WorkingLanguage.Id);
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
formattedAttribute = $"{attributeName}: {HtmlHelper.FormatText(valueStr, false, true, false, false, false, false)}";
//we never encode multiline textbox input
}
else if (attribute.AttributeControlType == AttributeControlType.FileUpload)
{
//file upload
Guid.TryParse(valueStr, out var downloadGuid);
var download = _downloadService.GetDownloadByGuid(downloadGuid);
if (download != null)
{
//TODO add a method for getting URL (use routing because it handles all SEO friendly URLs)
string attributeText;
var fileName = $"{download.Filename ?? download.DownloadGuid.ToString()}{download.Extension}";
//encode (if required)
if (htmlEncode)
{
fileName = WebUtility.HtmlEncode(fileName);
}
if (allowHyperlinks)
{
//hyperlinks are allowed
var downloadLink = $"{_webHelper.GetStoreLocation(false)}download/getfileupload/?downloadId={download.DownloadGuid}";
attributeText = $"<a href=\"{downloadLink}\" class=\"fileuploadattribute\">{fileName}</a>";
}
else
{
//hyperlinks aren't allowed
attributeText = fileName;
}
var attributeName = _localizationService.GetLocalized(attribute, a => a.Name, _workContext.WorkingLanguage.Id);
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
formattedAttribute = $"{attributeName}: {attributeText}";
}
}
else
{
//other attributes (textbox, datepicker)
formattedAttribute = $"{_localizationService.GetLocalized(attribute, a => a.Name, _workContext.WorkingLanguage.Id)}: {valueStr}";
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
}
}
else
{
if (int.TryParse(valueStr, out var attributeValueId))
{
var attributeValue = _checkoutAttributeService.GetCheckoutAttributeValueById(attributeValueId);
if (attributeValue != null)
{
formattedAttribute = $"{_localizationService.GetLocalized(attribute, a => a.Name, _workContext.WorkingLanguage.Id)}: {_localizationService.GetLocalized(attributeValue, a => a.Name, _workContext.WorkingLanguage.Id)}";
if (renderPrices)
{
var priceAdjustmentBase = _taxService.GetCheckoutAttributePrice(attributeValue, customer);
var priceAdjustment = _currencyService.ConvertFromPrimaryStoreCurrency(priceAdjustmentBase, _workContext.WorkingCurrency);
if (priceAdjustmentBase > 0)
{
var priceAdjustmentStr = _priceFormatter.FormatPrice(priceAdjustment);
formattedAttribute += $" [+{priceAdjustmentStr}]";
}
}
}
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
}
}
if (string.IsNullOrEmpty(formattedAttribute))
{
continue;
}
if (i != 0 || j != 0)
{
result.Append(separator);
}
result.Append(formattedAttribute);
}
}
return(result.ToString());
}
/// <summary>
/// Gets the base price
/// </summary>
/// <param name="product">Product</param>
/// <param name="localizationService">Localization service</param>
/// <param name="priceFormatter">Price formatter</param>
/// <param name="priceAdjustment">Price adjustment</param>
/// <param name="languageIndependent">Whether the result string should be language independent</param>
/// <returns>The base price</returns>
public static string GetBasePriceInfo(this Product product, ILocalizationService localizationService, IPriceFormatter priceFormatter,
ICurrencyService currencyService, ITaxService taxService, IPriceCalculationService priceCalculationService,
Currency currency, decimal priceAdjustment = decimal.Zero, bool languageIndependent = false)
{
if (product == null)
throw new ArgumentNullException("product");
if (localizationService == null && !languageIndependent)
throw new ArgumentNullException("localizationService");
if (product.BasePriceHasValue && product.BasePriceAmount != Decimal.Zero)
{
var workContext = EngineContext.Current.Resolve<IWorkContext>();
var taxrate = decimal.Zero;
var currentPrice = priceCalculationService.GetFinalPrice(product, workContext.CurrentCustomer, true);
decimal price = taxService.GetProductPrice(product, decimal.Add(currentPrice, priceAdjustment), out taxrate);
price = currencyService.ConvertFromPrimaryStoreCurrency(price, currency);
decimal basePriceValue = Convert.ToDecimal((price / product.BasePriceAmount) * product.BasePriceBaseAmount);
string basePrice = priceFormatter.FormatPrice(basePriceValue, true, currency);
string unit = "{0} {1}".FormatWith(product.BasePriceBaseAmount, product.BasePriceMeasureUnit);
if (languageIndependent)
{
return "{0} / {1}".FormatWith(basePrice, unit);
}
return localizationService.GetResource("Products.BasePriceInfo").FormatWith(basePrice, unit);
}
return "";
}
public virtual ActionResult AffiliatedSubscriptionListGrid(DataSourceRequest command, AffiliatedSubscriptionListModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageAffiliates))
{
return(AccessDeniedKendoGridJson());
}
var affiliate = _affiliateService.GetAffiliateById(model.AffliateId);
if (affiliate == null)
{
throw new ArgumentException("No affiliate found with the specified id");
}
DateTime?startDateValue = (model.StartDate == null) ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(model.StartDate.Value, _dateTimeHelper.CurrentTimeZone);
DateTime?endDateValue = (model.EndDate == null) ? null
: (DateTime?)_dateTimeHelper.ConvertToUtcTime(model.EndDate.Value, _dateTimeHelper.CurrentTimeZone).AddDays(1);
var subscriptionStatusIds = model.SubscriptionStatusId > 0 ? new List <int>()
{
model.SubscriptionStatusId
} : null;
var paymentStatusIds = model.PaymentStatusId > 0 ? new List <int>()
{
model.PaymentStatusId
} : null;
var shippingStatusIds = model.ShippingStatusId > 0 ? new List <int>()
{
model.ShippingStatusId
} : null;
var subscriptions = _subscriptionService.SearchSubscriptions(
createdFromUtc: startDateValue,
createdToUtc: endDateValue,
osIds: subscriptionStatusIds,
psIds: paymentStatusIds,
ssIds: shippingStatusIds,
affiliateId: affiliate.Id,
pageIndex: command.Page - 1,
pageSize: command.PageSize);
var gridModel = new DataSourceResult
{
Data = subscriptions.Select(subscription =>
{
var subscriptionModel = new AffiliateModel.AffiliatedSubscriptionModel();
subscriptionModel.Id = subscription.Id;
subscriptionModel.SubscriptionStatus = subscription.SubscriptionStatus.GetLocalizedEnum(_localizationService, _workContext);
subscriptionModel.SubscriptionStatusId = subscription.SubscriptionStatusId;
subscriptionModel.PaymentStatus = subscription.PaymentStatus.GetLocalizedEnum(_localizationService, _workContext);
subscriptionModel.SubscriptionTotal = _priceFormatter.FormatPrice(subscription.SubscriptionTotal, true, false);
subscriptionModel.CreatedOn = _dateTimeHelper.ConvertToUserTime(subscription.CreatedOnUtc, DateTimeKind.Utc);
subscriptionModel.CustomSubscriptionNumber = subscription.CustomSubscriptionNumber;
return(subscriptionModel);
}),
Total = subscriptions.TotalCount
};
return(Json(gridModel));
}
public virtual void LoadPriceRangeFilters(string priceRangeStr, IWebHelper webHelper, IPriceFormatter priceFormatter)
{
var priceRangeList = GetPriceRangeList(priceRangeStr);
if (priceRangeList.Count > 0)
{
this.Enabled = true;
var selectedPriceRange = GetSelectedPriceRange(webHelper, priceRangeStr);
this.Items = priceRangeList.ToList().Select(x =>
{
//from&to
var item = new PriceRangeFilterItem();
if (x.From.HasValue)
item.From = priceFormatter.FormatPrice(x.From.Value, true, false);
if (x.To.HasValue)
item.To = priceFormatter.FormatPrice(x.To.Value, true, false);
string fromQuery = string.Empty;
if (x.From.HasValue)
fromQuery = x.From.Value.ToString(new CultureInfo("en-US"));
string toQuery = string.Empty;
if (x.To.HasValue)
toQuery = x.To.Value.ToString(new CultureInfo("en-US"));
//is selected?
if (selectedPriceRange != null
&& selectedPriceRange.From == x.From
&& selectedPriceRange.To == x.To)
item.Selected = true;
//filter URL
string url = webHelper.ModifyQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM + "=" + fromQuery + "-" + toQuery, null);
url = ExcludeQueryStringParams(url, webHelper);
item.FilterUrl = url;
return item;
}).ToList();
if (selectedPriceRange != null)
{
//remove filter URL
string url = webHelper.RemoveQueryString(webHelper.GetThisPageUrl(true), QUERYSTRINGPARAM);
url = ExcludeQueryStringParams(url, webHelper);
this.RemoveFilterUrl = url;
}
}
else
{
this.Enabled = false;
}
}
protected OrderDetailsModel PrepareOrderDetailsModel(Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
var model = new OrderDetailsModel();
model.Id = order.Id;
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc);
model.OrderStatus = order.OrderStatus.GetLocalizedEnum(_localizationService, _workContext);
model.IsReOrderAllowed = _orderSettings.IsReOrderAllowed;
model.IsReturnRequestAllowed = _orderProcessingService.IsReturnRequestAllowed(order);
//shipping info
model.ShippingStatus = order.ShippingStatus.GetLocalizedEnum(_localizationService, _workContext);
if (order.ShippingStatus != ShippingStatus.ShippingNotRequired)
{
model.IsShippable = true;
model.ShippingAddress.PrepareModel(order.ShippingAddress, false, _addressSettings);
model.ShippingMethod = order.ShippingMethod;
//shipments (only already shipped)
var shipments = order.Shipments.Where(x => x.ShippedDateUtc.HasValue).OrderBy(x => x.CreatedOnUtc).ToList();
foreach (var shipment in shipments)
{
var shipmentModel = new OrderDetailsModel.ShipmentBriefModel()
{
Id = shipment.Id,
TrackingNumber = shipment.TrackingNumber,
};
if (shipment.ShippedDateUtc.HasValue)
{
shipmentModel.ShippedDate = _dateTimeHelper.ConvertToUserTime(shipment.ShippedDateUtc.Value, DateTimeKind.Utc);
}
if (shipment.DeliveryDateUtc.HasValue)
{
shipmentModel.DeliveryDate = _dateTimeHelper.ConvertToUserTime(shipment.DeliveryDateUtc.Value, DateTimeKind.Utc);
}
model.Shipments.Add(shipmentModel);
}
}
//billing info
model.BillingAddress.PrepareModel(order.BillingAddress, false, _addressSettings);
//VAT number
model.VatNumber = order.VatNumber;
//payment method
var paymentMethod = _paymentService.LoadPaymentMethodBySystemName(order.PaymentMethodSystemName);
model.PaymentMethod = paymentMethod != null?paymentMethod.GetLocalizedFriendlyName(_localizationService, _workContext.WorkingLanguage.Id) : order.PaymentMethodSystemName;
model.CanRePostProcessPayment = _paymentService.CanRePostProcessPayment(order);
//purchase order number (we have to find a better to inject this information because it's related to a certain plugin)
if (paymentMethod != null && paymentMethod.PluginDescriptor.SystemName.Equals("Payments.PurchaseOrder", StringComparison.InvariantCultureIgnoreCase))
{
model.DisplayPurchaseOrderNumber = true;
model.PurchaseOrderNumber = order.PurchaseOrderNumber;
}
//totals
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
//order subtotal
var orderSubtotalExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalExclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
//discount (applied to order subtotal)
var orderSubTotalDiscountExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountExclTax, order.CurrencyRate);
if (orderSubTotalDiscountExclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
//order shipping
var orderShippingExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingExclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
//payment method additional fee
var paymentMethodAdditionalFeeExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeExclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeExclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
break;
case TaxDisplayType.IncludingTax:
{
//order subtotal
var orderSubtotalInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubtotalInclTax, order.CurrencyRate);
model.OrderSubtotal = _priceFormatter.FormatPrice(orderSubtotalInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
//discount (applied to order subtotal)
var orderSubTotalDiscountInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderSubTotalDiscountInclTax, order.CurrencyRate);
if (orderSubTotalDiscountInclTaxInCustomerCurrency > decimal.Zero)
{
model.OrderSubTotalDiscount = _priceFormatter.FormatPrice(-orderSubTotalDiscountInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
//order shipping
var orderShippingInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderShippingInclTax, order.CurrencyRate);
model.OrderShipping = _priceFormatter.FormatShippingPrice(orderShippingInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
//payment method additional fee
var paymentMethodAdditionalFeeInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.PaymentMethodAdditionalFeeInclTax, order.CurrencyRate);
if (paymentMethodAdditionalFeeInclTaxInCustomerCurrency > decimal.Zero)
{
model.PaymentMethodAdditionalFee = _priceFormatter.FormatPaymentMethodAdditionalFee(paymentMethodAdditionalFeeInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
}
break;
}
//tax
bool displayTax = true;
bool displayTaxRates = true;
if (_taxSettings.HideTaxInOrderSummary && order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
if (order.OrderTax == 0 && _taxSettings.HideZeroTax)
{
displayTax = false;
displayTaxRates = false;
}
else
{
displayTaxRates = _taxSettings.DisplayTaxRates && order.TaxRatesDictionary.Count > 0;
displayTax = !displayTaxRates;
var orderTaxInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTax, order.CurrencyRate);
//TODO pass languageId to _priceFormatter.FormatPrice
model.Tax = _priceFormatter.FormatPrice(orderTaxInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
foreach (var tr in order.TaxRatesDictionary)
{
model.TaxRates.Add(new OrderDetailsModel.TaxRate()
{
Rate = _priceFormatter.FormatTaxRate(tr.Key),
//TODO pass languageId to _priceFormatter.FormatPrice
Value = _priceFormatter.FormatPrice(_currencyService.ConvertCurrency(tr.Value, order.CurrencyRate), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage),
});
}
}
}
model.DisplayTaxRates = displayTaxRates;
model.DisplayTax = displayTax;
//discount (applied to order total)
var orderDiscountInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderDiscount, order.CurrencyRate);
if (orderDiscountInCustomerCurrency > decimal.Zero)
{
model.OrderTotalDiscount = _priceFormatter.FormatPrice(-orderDiscountInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
}
//gift cards
foreach (var gcuh in order.GiftCardUsageHistory)
{
model.GiftCards.Add(new OrderDetailsModel.GiftCard()
{
CouponCode = gcuh.GiftCard.GiftCardCouponCode,
Amount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(gcuh.UsedValue, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage),
});
}
//reward points
if (order.RedeemedRewardPointsEntry != null)
{
model.RedeemedRewardPoints = -order.RedeemedRewardPointsEntry.Points;
model.RedeemedRewardPointsAmount = _priceFormatter.FormatPrice(-(_currencyService.ConvertCurrency(order.RedeemedRewardPointsEntry.UsedAmount, order.CurrencyRate)), true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
}
//total
var orderTotalInCustomerCurrency = _currencyService.ConvertCurrency(order.OrderTotal, order.CurrencyRate);
model.OrderTotal = _priceFormatter.FormatPrice(orderTotalInCustomerCurrency, true, order.CustomerCurrencyCode, false, _workContext.WorkingLanguage);
//checkout attributes
model.CheckoutAttributeInfo = order.CheckoutAttributeDescription;
//order notes
foreach (var orderNote in order.OrderNotes
.Where(on => on.DisplayToCustomer)
.OrderByDescending(on => on.CreatedOnUtc)
.ToList())
{
model.OrderNotes.Add(new OrderDetailsModel.OrderNote()
{
Note = orderNote.FormatOrderNoteText(),
CreatedOn = _dateTimeHelper.ConvertToUserTime(orderNote.CreatedOnUtc, DateTimeKind.Utc)
});
}
//purchased products
model.ShowSku = _catalogSettings.ShowProductSku;
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = new OrderDetailsModel.OrderItemModel()
{
Id = orderItem.Id,
Sku = orderItem.Product.FormatSku(orderItem.AttributesXml, _productAttributeParser),
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
Quantity = orderItem.Quantity,
AttributeInfo = orderItem.AttributeDescription,
};
model.Items.Add(orderItemModel);
//unit price, subtotal
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
var priceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceExclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
var priceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.PriceInclTax, order.CurrencyRate);
orderItemModel.SubTotal = _priceFormatter.FormatPrice(priceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
break;
}
}
return(model);
}
public static IEnumerable<ProductOverviewModel> PrepareProductOverviewModels(this Controller controller,
IWorkContext workContext,
IStoreContext storeContext,
ICategoryService categoryService,
IProductService productService,
ISpecificationAttributeService specificationAttributeService,
IPriceCalculationService priceCalculationService,
IPriceFormatter priceFormatter,
IPermissionService permissionService,
ILocalizationService localizationService,
ITaxService taxService,
ICurrencyService currencyService,
IPictureService pictureService,
IWebHelper webHelper,
ICacheManager cacheManager,
CatalogSettings catalogSettings,
MediaSettings mediaSettings,
IEnumerable<Product> products,
bool preparePriceModel = true, bool preparePictureModel = true,
int? productThumbPictureSize = null, bool prepareSpecificationAttributes = false,
bool forceRedirectionAfterAddingToCart = false)
{
if (products == null)
throw new ArgumentNullException("products");
var models = new List<ProductOverviewModel>();
foreach (var product in products)
{
var model = new ProductOverviewModel
{
Id = product.Id,
Name = product.GetLocalized(x => x.Name),
ShortDescription = product.GetLocalized(x => x.ShortDescription),
FullDescription = product.GetLocalized(x => x.FullDescription),
SeName = product.GetSeName(),
};
//price
if (preparePriceModel)
{
#region Prepare product price
var priceModel = new ProductOverviewModel.ProductPriceModel
{
ForceRedirectionAfterAddingToCart = forceRedirectionAfterAddingToCart
};
switch (product.ProductType)
{
case ProductType.GroupedProduct:
{
#region Grouped product
var associatedProducts = productService.GetAssociatedProducts(product.Id, storeContext.CurrentStore.Id);
switch (associatedProducts.Count)
{
case 0:
{
//no associated products
//priceModel.DisableBuyButton = true;
//priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//priceModel.AvailableForPreOrder = false;
}
break;
default:
{
//we have at least one associated product
//priceModel.DisableBuyButton = true;
//priceModel.DisableWishlistButton = true;
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//priceModel.AvailableForPreOrder = false;
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
//find a minimum possible price
decimal? minPossiblePrice = null;
Product minPriceProduct = null;
foreach (var associatedProduct in associatedProducts)
{
//calculate for the maximum quantity (in case if we have tier prices)
var tmpPrice = priceCalculationService.GetFinalPrice(associatedProduct,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
if (!minPossiblePrice.HasValue || tmpPrice < minPossiblePrice.Value)
{
minPriceProduct = associatedProduct;
minPossiblePrice = tmpPrice;
}
}
if (minPriceProduct != null && !minPriceProduct.CustomerEntersPrice)
{
if (minPriceProduct.CallForPrice)
{
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else if (minPossiblePrice.HasValue)
{
//calculate prices
decimal taxRate;
decimal finalPriceBase = taxService.GetProductPrice(minPriceProduct, minPossiblePrice.Value, out taxRate);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
//Actually it's not possible (we presume that minimalPrice always has a value)
//We never should get here
Debug.WriteLine("Cannot calculate minPrice for product #{0}", product.Id);
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
}
break;
}
#endregion
}
break;
case ProductType.SimpleProduct:
default:
{
#region Simple product
//add to cart button
priceModel.DisableBuyButton = product.DisableBuyButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableShoppingCart) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//add to wishlist button
priceModel.DisableWishlistButton = product.DisableWishlistButton ||
!permissionService.Authorize(StandardPermissionProvider.EnableWishlist) ||
!permissionService.Authorize(StandardPermissionProvider.DisplayPrices);
//compare products
priceModel.DisableAddToCompareListButton = !catalogSettings.CompareProductsEnabled;
//rental
priceModel.IsRental = product.IsRental;
//pre-order
if (product.AvailableForPreOrder)
{
priceModel.AvailableForPreOrder = !product.PreOrderAvailabilityStartDateTimeUtc.HasValue ||
product.PreOrderAvailabilityStartDateTimeUtc.Value >= DateTime.UtcNow;
priceModel.PreOrderAvailabilityStartDateTimeUtc = product.PreOrderAvailabilityStartDateTimeUtc;
}
//prices
if (permissionService.Authorize(StandardPermissionProvider.DisplayPrices))
{
if (!product.CustomerEntersPrice)
{
if (product.CallForPrice)
{
//call for price
priceModel.OldPrice = null;
priceModel.Price = localizationService.GetResource("Products.CallForPrice");
}
else
{
//prices
//calculate for the maximum quantity (in case if we have tier prices)
decimal minPossiblePrice = priceCalculationService.GetFinalPrice(product,
workContext.CurrentCustomer, decimal.Zero, true, int.MaxValue);
decimal taxRate;
decimal oldPriceBase = taxService.GetProductPrice(product, product.OldPrice, out taxRate);
decimal finalPriceBase = taxService.GetProductPrice(product, minPossiblePrice, out taxRate);
decimal oldPrice = currencyService.ConvertFromPrimaryStoreCurrency(oldPriceBase, workContext.WorkingCurrency);
decimal finalPrice = currencyService.ConvertFromPrimaryStoreCurrency(finalPriceBase, workContext.WorkingCurrency);
//do we have tier prices configured?
var tierPrices = new List<TierPrice>();
if (product.HasTierPrices)
{
tierPrices.AddRange(product.TierPrices
.OrderBy(tp => tp.Quantity)
.ToList()
.FilterByStore(storeContext.CurrentStore.Id)
.FilterForCustomer(workContext.CurrentCustomer)
.RemoveDuplicatedQuantities());
}
//When there is just one tier (with qty 1),
//there are no actual savings in the list.
bool displayFromMessage = tierPrices.Count > 0 &&
!(tierPrices.Count == 1 && tierPrices[0].Quantity <= 1);
if (displayFromMessage)
{
priceModel.OldPrice = null;
priceModel.Price = String.Format(localizationService.GetResource("Products.PriceRangeFrom"), priceFormatter.FormatPrice(finalPrice));
}
else
{
if (finalPriceBase != oldPriceBase && oldPriceBase != decimal.Zero)
{
priceModel.OldPrice = priceFormatter.FormatPrice(oldPrice);
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
else
{
priceModel.OldPrice = null;
priceModel.Price = priceFormatter.FormatPrice(finalPrice);
}
}
if (product.IsRental)
{
//rental product
priceModel.OldPrice = priceFormatter.FormatRentalProductPeriod(product, priceModel.OldPrice);
priceModel.Price = priceFormatter.FormatRentalProductPeriod(product, priceModel.Price);
}
//property for German market
//we display tax/shipping info only with "shipping enabled" for this product
//we also ensure this it's not free shipping
priceModel.DisplayTaxShippingInfo = catalogSettings.DisplayTaxShippingInfoProductBoxes
&& product.IsShipEnabled &&
!product.IsFreeShipping;
}
}
}
else
{
//hide prices
priceModel.OldPrice = null;
priceModel.Price = null;
}
#endregion
}
break;
}
model.ProductPrice = priceModel;
#endregion
}
//picture
if (preparePictureModel)
{
#region Prepare product picture
//If a size has been set in the view, we use it in priority
int pictureSize = productThumbPictureSize.HasValue ? productThumbPictureSize.Value : mediaSettings.ProductThumbPictureSize;
//prepare picture model
var defaultProductPictureCacheKey = string.Format(ModelCacheEventConsumer.PRODUCT_DEFAULTPICTURE_MODEL_KEY, product.Id, pictureSize, true, workContext.WorkingLanguage.Id, webHelper.IsCurrentConnectionSecured(), storeContext.CurrentStore.Id);
model.DefaultPictureModel = cacheManager.Get(defaultProductPictureCacheKey, () =>
{
var picture = pictureService.GetPicturesByProductId(product.Id, 1).FirstOrDefault();
var pictureModel = new PictureModel
{
ImageUrl = pictureService.GetPictureUrl(picture, pictureSize),
FullSizeImageUrl = pictureService.GetPictureUrl(picture)
};
//"title" attribute
pictureModel.Title = (picture != null && !string.IsNullOrEmpty(picture.TitleAttribute)) ?
picture.TitleAttribute :
string.Format(localizationService.GetResource("Media.Product.ImageLinkTitleFormat"), model.Name);
//"alt" attribute
pictureModel.AlternateText = (picture != null && !string.IsNullOrEmpty(picture.AltAttribute)) ?
picture.AltAttribute :
string.Format(localizationService.GetResource("Media.Product.ImageAlternateTextFormat"), model.Name);
return pictureModel;
});
#endregion
}
//specs
if (prepareSpecificationAttributes)
{
model.SpecificationAttributeModels = PrepareProductSpecificationModel(controller, workContext,
specificationAttributeService, cacheManager, product);
}
//reviews
model.ReviewOverviewModel = new ProductReviewOverviewModel
{
ProductId = product.Id,
RatingSum = product.ApprovedRatingSum,
TotalReviews = product.ApprovedTotalReviews,
AllowCustomerReviews = product.AllowCustomerReviews
};
models.Add(model);
}
return models;
}
/// <summary>
/// Gets the base price info
/// </summary>
/// <param name="product">Product</param>
/// <param name="productPrice">The calculated product price</param>
/// <param name="localizationService">Localization service</param>
/// <param name="priceFormatter">Price formatter</param>
/// <param name="currency">Target currency</param>
/// <param name="languageInsensitive">Whether the result string should be language insensitive</param>
/// <returns>The base price info</returns>
public static string GetBasePriceInfo(this Product product,
decimal productPrice,
ILocalizationService localizationService,
IPriceFormatter priceFormatter,
Currency currency,
bool languageInsensitive = false)
{
Guard.ArgumentNotNull(() => product);
Guard.ArgumentNotNull(() => localizationService);
Guard.ArgumentNotNull(() => priceFormatter);
Guard.ArgumentNotNull(() => currency);
if (product.BasePriceHasValue && product.BasePriceAmount != Decimal.Zero)
{
var value = Convert.ToDecimal((productPrice / product.BasePriceAmount) * product.BasePriceBaseAmount);
var valueFormatted = priceFormatter.FormatPrice(value, true, currency);
var amountFormatted = Math.Round(product.BasePriceAmount.Value, 2).ToString("G29");
var infoTemplate = localizationService.GetResource(languageInsensitive ? "Products.BasePriceInfo.LanguageInsensitive" : "Products.BasePriceInfo");
var result = infoTemplate.FormatInvariant(
amountFormatted,
product.BasePriceMeasureUnit,
valueFormatted,
product.BasePriceBaseAmount
);
return result;
}
return "";
}