public async Task <string> FormatAttributesAsync(
CheckoutAttributeSelection selection,
Customer customer = null,
string serapator = "<br />",
bool htmlEncode = true,
bool renderPrices = true,
bool allowHyperlinks = true)
{
Guard.NotNull(selection, nameof(selection));
customer ??= _workContext.CurrentCustomer;
using var psb = StringBuilderPool.Instance.Get(out var sb);
var attributesList = await _checkoutAttributeMaterializer.MaterializeCheckoutAttributesAsync(selection);
if (attributesList.IsNullOrEmpty())
{
return(null);
}
var attributeValues = attributesList
.Where(x => x.IsListTypeAttribute)
.SelectMany(x => x.CheckoutAttributeValues);
var language = _workContext.WorkingLanguage;
for (var i = 0; i < attributesList.Count; i++)
{
var currentAttribute = attributesList[i];
var currentAttributeValues = selection.GetAttributeValues(currentAttribute.Id).ToList();
for (var j = 0; j < currentAttributeValues.Count; j++)
{
var currentValue = currentAttributeValues[j].ToString();
var attributeStr = string.Empty;
if (!currentAttribute.IsListTypeAttribute)
{
if (currentAttribute.AttributeControlType is AttributeControlType.MultilineTextbox)
{
// Multiline textbox input gets never encoded
var attributeName = currentAttribute.GetLocalized(a => a.Name, language).ToString();
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
attributeStr = $"{attributeName}: {HtmlUtils.ConvertPlainTextToHtml(currentValue.EmptyNull().Replace(":", string.Empty).HtmlEncode())}";
}
else if (currentAttribute.AttributeControlType is AttributeControlType.FileUpload)
{
Guid.TryParse(currentValue, out var downloadGuid);
var download = await _db.Downloads
.Include(x => x.MediaFile)
.Where(x => x.DownloadGuid == downloadGuid)
.FirstOrDefaultAsync();
if (download?.MediaFile != null)
{
// TODO: (ms) (core) add a method for getting URL (use routing because it handles all SEO friendly URLs) ?
//var genratedUrl = _mediaService.GenerateFileDownloadUrl(download.MediaFileId, 0);
var attributeText = string.Empty;
var fileName = download.MediaFile.Name;
if (htmlEncode)
{
fileName = HttpUtility.HtmlEncode(fileName);
}
if (allowHyperlinks)
{
var downloadLink = $"{_webHelper.GetStoreLocation()}download/getfileupload/?downloadId={download.DownloadGuid}";
attributeText = $"<a href='{downloadLink}' class='fileuploadattribute'>{fileName}</a>";
}
else
{
attributeText = fileName;
}
var attributeName = currentAttribute.GetLocalized(a => a.Name, language).ToString();
if (htmlEncode)
{
attributeName = HttpUtility.HtmlEncode(attributeName);
}
attributeStr = $"{attributeName}: {attributeText}";
}
}
else
{
// Other attributes (textbox, datepicker...)
attributeStr = $"{currentAttribute.GetLocalized(a => a.Name, language)}: {currentValue}";
if (htmlEncode)
{
attributeStr = HttpUtility.HtmlEncode(attributeStr);
}
}
}
else
{
if (int.TryParse(currentValue, out var id))
{
var attributeValue = attributeValues.Where(x => x.Id == id).FirstOrDefault();
if (attributeValue != null)
{
attributeStr = $"{currentAttribute.GetLocalized(x => x.Name, language)}: {attributeValue.GetLocalized(x => x.Name, language)}";
if (renderPrices)
{
var adjustment = await _taxCalculator.CalculateCheckoutAttributeTaxAsync(attributeValue, customer : customer);
if (adjustment.Price > 0m)
{
var convertedAdjustment = _currencyService.ConvertToWorkingCurrency(adjustment.Price);
attributeStr += $" [+{_currencyService.ApplyTaxFormat(convertedAdjustment).ToString()}]";
}
}
}
if (htmlEncode)
{
attributeStr = HttpUtility.HtmlEncode(attributeStr);
}
}
}
if (attributeStr.HasValue())
{
if (i != 0 || j != 0)
{
sb.Append(serapator);
}
sb.Append(attributeStr);
}
}
}
return(sb.ToString());
}
public override async Task MapAsync(IEnumerable <OrganizedShoppingCartItem> from, ShoppingCartModel to, dynamic parameters = null)
{
Guard.NotNull(from, nameof(from));
Guard.NotNull(to, nameof(to));
if (!from.Any())
{
return;
}
await base.MapAsync(from, to, null);
var store = _services.StoreContext.CurrentStore;
var customer = _services.WorkContext.CurrentCustomer;
var currency = _services.WorkContext.WorkingCurrency;
var isEditable = parameters?.IsEditable == true;
var validateCheckoutAttributes = parameters?.ValidateCheckoutAttributes == true;
var prepareEstimateShippingIfEnabled = parameters?.PrepareEstimateShippingIfEnabled == true;
var setEstimateShippingDefaultAddress = parameters?.SetEstimateShippingDefaultAddress == true;
var prepareAndDisplayOrderReviewData = parameters?.PrepareAndDisplayOrderReviewData == true;
#region Simple properties
to.MediaDimensions = _mediaSettings.CartThumbPictureSize;
to.DeliveryTimesPresentation = _shoppingCartSettings.DeliveryTimesInShoppingCart;
to.DisplayBasePrice = _shoppingCartSettings.ShowBasePrice;
to.DisplayWeight = _shoppingCartSettings.ShowWeight;
to.DisplayMoveToWishlistButton = await _services.Permissions.AuthorizeAsync(Permissions.Cart.AccessWishlist);
to.TermsOfServiceEnabled = _orderSettings.TermsOfServiceEnabled;
to.DisplayCommentBox = _shoppingCartSettings.ShowCommentBox;
to.DisplayEsdRevocationWaiverBox = _shoppingCartSettings.ShowEsdRevocationWaiverBox;
to.IsEditable = isEditable;
var measure = await _db.MeasureWeights.FindByIdAsync(_measureSettings.BaseWeightId, false);
if (measure != null)
{
to.MeasureUnitName = measure.GetLocalized(x => x.Name);
}
to.CheckoutAttributeInfo = HtmlUtils.ConvertPlainTextToTable(
HtmlUtils.ConvertHtmlToPlainText(
await _checkoutAttributeFormatter.FormatAttributesAsync(customer.GenericAttributes.CheckoutAttributes, customer)));
// Gift card and gift card boxes.
to.DiscountBox.Display = _shoppingCartSettings.ShowDiscountBox;
var discountCouponCode = customer.GenericAttributes.DiscountCouponCode;
var discount = await _db.Discounts
.AsNoTracking()
.Where(x => x.CouponCode == discountCouponCode)
.FirstOrDefaultAsync();
if (discount != null &&
discount.RequiresCouponCode &&
await _discountService.IsDiscountValidAsync(discount, customer))
{
to.DiscountBox.CurrentCode = discount.CouponCode;
}
to.GiftCardBox.Display = _shoppingCartSettings.ShowGiftCardBox;
// Reward points.
if (_rewardPointsSettings.Enabled && !from.IncludesMatchingItems(x => x.IsRecurring) && !customer.IsGuest())
{
var rewardPointsBalance = customer.GetRewardPointsBalance();
var rewardPointsAmountBase = _orderCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
var rewardPointsAmount = _currencyService.ConvertFromPrimaryCurrency(rewardPointsAmountBase.Amount, currency);
if (rewardPointsAmount > decimal.Zero)
{
to.RewardPoints.DisplayRewardPoints = true;
to.RewardPoints.RewardPointsAmount = rewardPointsAmount.ToString(true);
to.RewardPoints.RewardPointsBalance = rewardPointsBalance;
to.RewardPoints.UseRewardPoints = customer.GenericAttributes.UseRewardPointsDuringCheckout;
}
}
// Cart warnings.
var warnings = new List <string>();
var cartIsValid = await _shoppingCartValidator.ValidateCartItemsAsync(from, warnings, validateCheckoutAttributes, customer.GenericAttributes.CheckoutAttributes);
if (!cartIsValid)
{
to.Warnings.AddRange(warnings);
}
#endregion
#region Checkout attributes
var checkoutAttributes = await _checkoutAttributeMaterializer.GetValidCheckoutAttributesAsync(from);
foreach (var attribute in checkoutAttributes)
{
var caModel = new ShoppingCartModel.CheckoutAttributeModel
{
Id = attribute.Id,
Name = attribute.GetLocalized(x => x.Name),
TextPrompt = attribute.GetLocalized(x => x.TextPrompt),
IsRequired = attribute.IsRequired,
AttributeControlType = attribute.AttributeControlType
};
if (attribute.IsListTypeAttribute)
{
var taxFormat = _currencyService.GetTaxFormat(null, null, PricingTarget.Product);
var caValues = await _db.CheckoutAttributeValues
.AsNoTracking()
.Where(x => x.CheckoutAttributeId == attribute.Id)
.ToListAsync();
// Prepare each attribute with image and price
foreach (var caValue in caValues)
{
var pvaValueModel = new ShoppingCartModel.CheckoutAttributeValueModel
{
Id = caValue.Id,
Name = caValue.GetLocalized(x => x.Name),
IsPreSelected = caValue.IsPreSelected,
Color = caValue.Color
};
if (caValue.MediaFileId.HasValue && caValue.MediaFile != null)
{
pvaValueModel.ImageUrl = _mediaService.GetUrl(caValue.MediaFile, _mediaSettings.VariantValueThumbPictureSize, null, false);
}
caModel.Values.Add(pvaValueModel);
// Display price if allowed.
if (await _services.Permissions.AuthorizeAsync(Permissions.Catalog.DisplayPrice))
{
var priceAdjustmentBase = await _taxCalculator.CalculateCheckoutAttributeTaxAsync(caValue);
var priceAdjustment = _currencyService.ConvertFromPrimaryCurrency(priceAdjustmentBase.Price, currency);
if (priceAdjustment > 0)
{
pvaValueModel.PriceAdjustment = "+" + priceAdjustment.WithPostFormat(taxFormat).ToString();
}
else if (priceAdjustment < 0)
{
pvaValueModel.PriceAdjustment = "-" + (priceAdjustment * -1).WithPostFormat(taxFormat).ToString();
}
}
}
}
// Set already selected attributes.
var selectedCheckoutAttributes = customer.GenericAttributes.CheckoutAttributes;
switch (attribute.AttributeControlType)
{
case AttributeControlType.DropdownList:
case AttributeControlType.RadioList:
case AttributeControlType.Boxes:
case AttributeControlType.Checkboxes:
if (selectedCheckoutAttributes.AttributesMap.Any())
{
// Clear default selection.
foreach (var item in caModel.Values)
{
item.IsPreSelected = false;
}
// Select new values.
var selectedCaValues = await _checkoutAttributeMaterializer.MaterializeCheckoutAttributeValuesAsync(selectedCheckoutAttributes);
foreach (var caValue in selectedCaValues)
{
foreach (var item in caModel.Values)
{
if (caValue.Id == item.Id)
{
item.IsPreSelected = true;
}
}
}
}
break;
case AttributeControlType.TextBox:
case AttributeControlType.MultilineTextbox:
if (selectedCheckoutAttributes.AttributesMap.Any())
{
var enteredText = selectedCheckoutAttributes.GetAttributeValues(attribute.Id)?
.Select(x => x.ToString())
.FirstOrDefault();
if (enteredText.HasValue())
{
caModel.TextValue = enteredText;
}
}
break;
case AttributeControlType.Datepicker:
{
// Keep in mind my that the code below works only in the current culture.
var enteredDate = selectedCheckoutAttributes.AttributesMap
.Where(x => x.Key == attribute.Id)
.SelectMany(x => x.Value)
.FirstOrDefault()
.ToString();
if (enteredDate.HasValue() &&
DateTime.TryParseExact(enteredDate, "D", CultureInfo.CurrentCulture, DateTimeStyles.None, out var selectedDate))
{
caModel.SelectedDay = selectedDate.Day;
caModel.SelectedMonth = selectedDate.Month;
caModel.SelectedYear = selectedDate.Year;
}
}
break;
case AttributeControlType.FileUpload:
if (selectedCheckoutAttributes.AttributesMap.Any())
{
var FileValue = selectedCheckoutAttributes.AttributesMap
.Where(x => x.Key == attribute.Id)
.Select(x => x.Value.ToString())
.FirstOrDefault();
if (FileValue.HasValue() && caModel.UploadedFileGuid.HasValue() && Guid.TryParse(caModel.UploadedFileGuid, out var guid))
{
var download = await _db.Downloads
.Include(x => x.MediaFile)
.FirstOrDefaultAsync(x => x.DownloadGuid == guid);
if (download != null && !download.UseDownloadUrl && download.MediaFile != null)
{
caModel.UploadedFileName = download.MediaFile.Name;
}
}
}
break;
default:
break;
}
to.CheckoutAttributes.Add(caModel);
}
#endregion
#region Estimate shipping
if (prepareEstimateShippingIfEnabled)
{
to.EstimateShipping.Enabled = _shippingSettings.EstimateShippingEnabled &&
from.Any() &&
from.IncludesMatchingItems(x => x.IsShippingEnabled);
if (to.EstimateShipping.Enabled)
{
// Countries.
var defaultEstimateCountryId = setEstimateShippingDefaultAddress && customer.ShippingAddress != null
? customer.ShippingAddress.CountryId
: to.EstimateShipping.CountryId;
var countriesForShipping = await _db.Countries
.AsNoTracking()
.ApplyStoreFilter(store.Id)
.Where(x => x.AllowsShipping)
.ToListAsync();
foreach (var countries in countriesForShipping)
{
to.EstimateShipping.AvailableCountries.Add(new SelectListItem
{
Text = countries.GetLocalized(x => x.Name),
Value = countries.Id.ToString(),
Selected = countries.Id == defaultEstimateCountryId
});
}
// States.
var states = defaultEstimateCountryId.HasValue
? await _db.StateProvinces.AsNoTracking().ApplyCountryFilter(defaultEstimateCountryId.Value).ToListAsync()
: new();
if (states.Any())
{
var defaultEstimateStateId = setEstimateShippingDefaultAddress && customer.ShippingAddress != null
? customer.ShippingAddress.StateProvinceId
: to.EstimateShipping.StateProvinceId;
foreach (var s in states)
{
to.EstimateShipping.AvailableStates.Add(new SelectListItem
{
Text = s.GetLocalized(x => x.Name),
Value = s.Id.ToString(),
Selected = s.Id == defaultEstimateStateId
});
}
}
else
{
to.EstimateShipping.AvailableStates.Add(new SelectListItem {
Text = T("Address.OtherNonUS"), Value = "0"
});
}
if (setEstimateShippingDefaultAddress && customer.ShippingAddress != null)
{
to.EstimateShipping.ZipPostalCode = customer.ShippingAddress.ZipPostalCode;
}
}
}
#endregion
#region Cart items
var allProducts = from
.Select(x => x.Item.Product)
.Union(from.Select(x => x.ChildItems).SelectMany(child => child.Select(x => x.Item.Product)))
.ToArray();
var batchContext = _productService.CreateProductBatchContext(allProducts, null, customer, false);
var subtotal = await _orderCalculationService.GetShoppingCartSubtotalAsync(from.ToList(), null, batchContext);
dynamic itemParameters = new ExpandoObject();
itemParameters.TaxFormat = _currencyService.GetTaxFormat();
itemParameters.BatchContext = batchContext;
itemParameters.CartSubtotal = subtotal;
foreach (var cartItem in from)
{
var model = new ShoppingCartModel.ShoppingCartItemModel();
await cartItem.MapAsync(model, (object)itemParameters);
to.AddItems(model);
}
#endregion
#region Order review data
if (prepareAndDisplayOrderReviewData)
{
var checkoutState = _httpContextAccessor.HttpContext?.GetCheckoutState();
to.OrderReviewData.Display = true;
// Billing info.
var billingAddress = customer.BillingAddress;
if (billingAddress != null)
{
await MapperFactory.MapAsync(billingAddress, to.OrderReviewData.BillingAddress);
}
// Shipping info.
if (from.IsShippingRequired())
{
to.OrderReviewData.IsShippable = true;
var shippingAddress = customer.ShippingAddress;
if (shippingAddress != null)
{
await MapperFactory.MapAsync(shippingAddress, to.OrderReviewData.ShippingAddress);
}
// Selected shipping method.
var shippingOption = customer.GenericAttributes.SelectedShippingOption;
if (shippingOption != null)
{
to.OrderReviewData.ShippingMethod = shippingOption.Name;
}
if (checkoutState != null && checkoutState.CustomProperties.ContainsKey("HasOnlyOneActiveShippingMethod"))
{
to.OrderReviewData.DisplayShippingMethodChangeOption = !(bool)checkoutState.CustomProperties.Get("HasOnlyOneActiveShippingMethod");
}
}
if (checkoutState != null && checkoutState.CustomProperties.ContainsKey("HasOnlyOneActivePaymentMethod"))
{
to.OrderReviewData.DisplayPaymentMethodChangeOption = !(bool)checkoutState.CustomProperties.Get("HasOnlyOneActivePaymentMethod");
}
var selectedPaymentMethodSystemName = customer.GenericAttributes.SelectedPaymentMethod;
var paymentMethod = await _paymentService.LoadPaymentMethodBySystemNameAsync(selectedPaymentMethodSystemName);
// TODO: (ms) (core) Wait for PluginMediator.GetLocalizedFriendlyName implementation
//model.OrderReviewData.PaymentMethod = paymentMethod != null ? _pluginMediator.GetLocalizedFriendlyName(paymentMethod.Metadata) : "";
to.OrderReviewData.PaymentSummary = checkoutState.PaymentSummary;
to.OrderReviewData.IsPaymentSelectionSkipped = checkoutState.IsPaymentSelectionSkipped;
}
#endregion
var paymentTypes = new PaymentMethodType[] { PaymentMethodType.Button, PaymentMethodType.StandardAndButton };
var boundPaymentMethods = await _paymentService.LoadActivePaymentMethodsAsync(
customer,
from.ToList(),
store.Id,
paymentTypes,
false);
var bpmModel = new ButtonPaymentMethodModel();
foreach (var boundPaymentMethod in boundPaymentMethods)
{
if (from.IncludesMatchingItems(x => x.IsRecurring) && boundPaymentMethod.Value.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
var widgetInvoker = boundPaymentMethod.Value.GetPaymentInfoWidget();
bpmModel.Items.Add(widgetInvoker);
}
to.ButtonPaymentMethods = bpmModel;
}
