/// <summary>
/// Prepare the currency selector model
/// </summary>
/// <returns>Currency selector model</returns>
public virtual async Task <CurrencySelectorModel> PrepareCurrencySelectorModelAsync()
{
var availableCurrencies = await(await _currencyService
.GetAllCurrenciesAsync(storeId: (await _storeContext.GetCurrentStoreAsync()).Id))
.SelectAwait(async x =>
{
//currency char
var currencySymbol = !string.IsNullOrEmpty(x.DisplayLocale)
? new RegionInfo(x.DisplayLocale).CurrencySymbol
: x.CurrencyCode;
//model
var currencyModel = new CurrencyModel
{
Id = x.Id,
Name = await _localizationService.GetLocalizedAsync(x, y => y.Name),
CurrencySymbol = currencySymbol
};
return(currencyModel);
}).ToListAsync();
var model = new CurrencySelectorModel
{
CurrentCurrencyId = (await _workContext.GetWorkingCurrencyAsync()).Id,
AvailableCurrencies = availableCurrencies
};
return(model);
}
protected virtual async Task <CustomCheckoutConfirmModel> PrepareConfirmOrderModelAsync(IList <ShoppingCartItem> cart)
{
var model = new CustomCheckoutConfirmModel
{
TermsOfServiceOnOrderConfirmPage = _orderSettings.TermsOfServiceOnOrderConfirmPage
};
//min order amount validation
bool minOrderTotalAmountOk = await _orderProcessingService.ValidateMinOrderTotalAmountAsync(cart);
if (!minOrderTotalAmountOk)
{
decimal minOrderTotalAmount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(
_orderSettings.MinOrderTotalAmount, await _workContext.GetWorkingCurrencyAsync()
);
model.MinOrderTotalWarning = string.Format(
await _localizationService.GetResourceAsync("Checkout.MinOrderTotalAmount"),
await _priceFormatter.FormatPriceAsync(minOrderTotalAmount, true, false)
);
}
model.SynchronyAuthTokenResponse = GetSynchronyAuthTokenResponse();
return(model);
}
/// <summary>
/// Prepare the customer reward points model
/// </summary>
/// <param name="page">Number of items page; pass null to load the first page</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the customer reward points model
/// </returns>
public virtual async Task <CustomerRewardPointsModel> PrepareCustomerRewardPointsAsync(int?page)
{
//get reward points history
var customer = await _workContext.GetCurrentCustomerAsync();
var store = await _storeContext.GetCurrentStoreAsync();
var pageSize = _rewardPointsSettings.PageSize;
var rewardPoints = await _rewardPointService.GetRewardPointsHistoryAsync(customer.Id, store.Id, true, pageIndex : --page ?? 0, pageSize : pageSize);
//prepare model
var model = new CustomerRewardPointsModel
{
RewardPoints = await rewardPoints.SelectAwait(async historyEntry =>
{
var activatingDate = await _dateTimeHelper.ConvertToUserTimeAsync(historyEntry.CreatedOnUtc, DateTimeKind.Utc);
return(new CustomerRewardPointsModel.RewardPointsHistoryModel
{
Points = historyEntry.Points,
PointsBalance = historyEntry.PointsBalance.HasValue ? historyEntry.PointsBalance.ToString()
: string.Format(await _localizationService.GetResourceAsync("RewardPoints.ActivatedLater"), activatingDate),
Message = historyEntry.Message,
CreatedOn = activatingDate,
EndDate = !historyEntry.EndDateUtc.HasValue ? null :
(DateTime?)(await _dateTimeHelper.ConvertToUserTimeAsync(historyEntry.EndDateUtc.Value, DateTimeKind.Utc))
});
}).ToListAsync(),
PagerModel = new PagerModel(_localizationService)
{
PageSize = rewardPoints.PageSize,
TotalRecords = rewardPoints.TotalCount,
PageIndex = rewardPoints.PageIndex,
ShowTotalSummary = true,
RouteActionName = "CustomerRewardPointsPaged",
UseRouteLinks = true,
RouteValues = new RewardPointsRouteValues {
pageNumber = page ?? 0
}
}
};
//current amount/balance
var rewardPointsBalance = await _rewardPointService.GetRewardPointsBalanceAsync(customer.Id, store.Id);
var rewardPointsAmountBase = await _orderTotalCalculationService.ConvertRewardPointsToAmountAsync(rewardPointsBalance);
var currentCurrency = await _workContext.GetWorkingCurrencyAsync();
var rewardPointsAmount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(rewardPointsAmountBase, currentCurrency);
model.RewardPointsBalance = rewardPointsBalance;
model.RewardPointsAmount = await _priceFormatter.FormatPriceAsync(rewardPointsAmount, true, false);
//minimum amount/balance
var minimumRewardPointsBalance = _rewardPointsSettings.MinimumRewardPointsToUse;
var minimumRewardPointsAmountBase = await _orderTotalCalculationService.ConvertRewardPointsToAmountAsync(minimumRewardPointsBalance);
var minimumRewardPointsAmount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(minimumRewardPointsAmountBase, currentCurrency);
model.MinimumRewardPointsBalance = minimumRewardPointsBalance;
model.MinimumRewardPointsAmount = await _priceFormatter.FormatPriceAsync(minimumRewardPointsAmount, true, false);
return(model);
}
/// <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>
/// A task that represents the asynchronous operation
/// The task result contains the attributes
/// </returns>
public virtual async Task <string> FormatAttributesAsync(string attributesXml,
Customer customer,
string separator = "<br />",
bool htmlEncode = true,
bool renderPrices = true,
bool allowHyperlinks = true)
{
var result = new StringBuilder();
var attributes = await _checkoutAttributeParser.ParseCheckoutAttributesAsync(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 = await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).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 = await _downloadService.GetDownloadByGuidAsync(downloadGuid);
if (download != null)
{
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 = await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id);
//encode (if required)
if (htmlEncode)
{
attributeName = WebUtility.HtmlEncode(attributeName);
}
formattedAttribute = $"{attributeName}: {attributeText}";
}
}
else
{
//other attributes (textbox, datepicker)
formattedAttribute = $"{await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}: {valueStr}";
//encode (if required)
if (htmlEncode)
{
formattedAttribute = WebUtility.HtmlEncode(formattedAttribute);
}
}
}
else
{
if (int.TryParse(valueStr, out var attributeValueId))
{
var attributeValue = await _checkoutAttributeService.GetCheckoutAttributeValueByIdAsync(attributeValueId);
if (attributeValue != null)
{
formattedAttribute = $"{await _localizationService.GetLocalizedAsync(attribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}: {await _localizationService.GetLocalizedAsync(attributeValue, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}";
if (renderPrices)
{
var priceAdjustmentBase = (await _taxService.GetCheckoutAttributePriceAsync(attribute, attributeValue, customer)).price;
var priceAdjustment = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(priceAdjustmentBase, await _workContext.GetWorkingCurrencyAsync());
if (priceAdjustmentBase > 0)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"+", await _priceFormatter.FormatPriceAsync(priceAdjustment), string.Empty);
}
}
}
//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>
/// Prepares the checkout pickup points model
/// </summary>
/// <param name="cart">Cart</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the checkout pickup points model
/// </returns>
protected virtual async Task <CheckoutPickupPointsModel> PrepareCheckoutPickupPointsModelAsync(IList <ShoppingCartItem> cart)
{
var model = new CheckoutPickupPointsModel
{
AllowPickupInStore = _shippingSettings.AllowPickupInStore
};
if (!model.AllowPickupInStore)
{
return(model);
}
model.DisplayPickupPointsOnMap = _shippingSettings.DisplayPickupPointsOnMap;
model.GoogleMapsApiKey = _shippingSettings.GoogleMapsApiKey;
var pickupPointProviders = await _pickupPluginManager.LoadActivePluginsAsync(await _workContext.GetCurrentCustomerAsync(), (await _storeContext.GetCurrentStoreAsync()).Id);
if (pickupPointProviders.Any())
{
var languageId = (await _workContext.GetWorkingLanguageAsync()).Id;
var pickupPointsResponse = await _shippingService.GetPickupPointsAsync((await _workContext.GetCurrentCustomerAsync()).BillingAddressId ?? 0,
await _workContext.GetCurrentCustomerAsync(), storeId : (await _storeContext.GetCurrentStoreAsync()).Id);
if (pickupPointsResponse.Success)
{
model.PickupPoints = await pickupPointsResponse.PickupPoints.SelectAwait(async point =>
{
var country = await _countryService.GetCountryByTwoLetterIsoCodeAsync(point.CountryCode);
var state = await _stateProvinceService.GetStateProvinceByAbbreviationAsync(point.StateAbbreviation, country?.Id);
var pickupPointModel = new CheckoutPickupPointModel
{
Id = point.Id,
Name = point.Name,
Description = point.Description,
ProviderSystemName = point.ProviderSystemName,
Address = point.Address,
City = point.City,
County = point.County,
StateName = state != null ? await _localizationService.GetLocalizedAsync(state, x => x.Name, languageId) : string.Empty,
CountryName = country != null ? await _localizationService.GetLocalizedAsync(country, x => x.Name, languageId) : string.Empty,
ZipPostalCode = point.ZipPostalCode,
Latitude = point.Latitude,
Longitude = point.Longitude,
OpeningHours = point.OpeningHours
};
var cart = await _shoppingCartService.GetShoppingCartAsync(await _workContext.GetCurrentCustomerAsync(), ShoppingCartType.ShoppingCart, (await _storeContext.GetCurrentStoreAsync()).Id);
var amount = await _orderTotalCalculationService.IsFreeShippingAsync(cart) ? 0 : point.PickupFee;
if (amount > 0)
{
(amount, _) = await _taxService.GetShippingPriceAsync(amount, await _workContext.GetCurrentCustomerAsync());
amount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(amount, await _workContext.GetWorkingCurrencyAsync());
pickupPointModel.PickupFee = await _priceFormatter.FormatShippingPriceAsync(amount, true);
}
//adjust rate
var(shippingTotal, _) = await _orderTotalCalculationService.AdjustShippingRateAsync(point.PickupFee, cart, true);
var(rateBase, _) = await _taxService.GetShippingPriceAsync(shippingTotal, await _workContext.GetCurrentCustomerAsync());
var rate = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(rateBase, await _workContext.GetWorkingCurrencyAsync());
pickupPointModel.PickupFee = await _priceFormatter.FormatShippingPriceAsync(rate, true);
return(pickupPointModel);
}).ToListAsync();
}
else
{
foreach (var error in pickupPointsResponse.Errors)
{
model.Warnings.Add(error);
}
}
}
//only available pickup points
var shippingProviders = await _shippingPluginManager.LoadActivePluginsAsync(await _workContext.GetCurrentCustomerAsync(), (await _storeContext.GetCurrentStoreAsync()).Id);
if (!shippingProviders.Any())
{
if (!pickupPointProviders.Any())
{
model.Warnings.Add(await _localizationService.GetResourceAsync("Checkout.ShippingIsNotAllowed"));
model.Warnings.Add(await _localizationService.GetResourceAsync("Checkout.PickupPoints.NotAvailable"));
}
model.PickupInStoreOnly = true;
model.PickupInStore = true;
return(model);
}
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="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>
/// A task that represents the asynchronous operation
/// The task result contains the attributes
/// </returns>
public virtual async Task <string> FormatAttributesAsync(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 await _productAttributeParser.ParseProductAttributeMappingsAsync(attributesXml))
{
var productAttribute = await _productAttributeService.GetProductAttributeByIdAsync(attribute.ProductAttributeId);
var attributeName = await _localizationService.GetLocalizedAsync(productAttribute, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).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 = await _downloadService.GetDownloadByGuidAsync(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 await _productAttributeParser.ParseProductAttributeValuesAsync(attributesXml, attribute.Id))
{
var formattedAttribute = $"{attributeName}: {await _localizationService.GetLocalizedAsync(attributeValue, a => a.Name, (await _workContext.GetWorkingLanguageAsync()).Id)}";
if (renderPrices)
{
if (attributeValue.PriceAdjustmentUsePercentage)
{
if (attributeValue.PriceAdjustment > decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"+", attributeValue.PriceAdjustment.ToString("G29"), "%");
}
else if (attributeValue.PriceAdjustment < decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
string.Empty, attributeValue.PriceAdjustment.ToString("G29"), "%");
}
}
else
{
var attributeValuePriceAdjustment = await _priceCalculationService.GetProductAttributeValuePriceAdjustmentAsync(product, attributeValue, customer);
var(priceAdjustmentBase, _) = await _taxService.GetProductPriceAsync(product, attributeValuePriceAdjustment, customer);
var priceAdjustment = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(priceAdjustmentBase, await _workContext.GetWorkingCurrencyAsync());
if (priceAdjustmentBase > decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"+", await _priceFormatter.FormatPriceAsync(priceAdjustment, false, false), string.Empty);
}
else if (priceAdjustmentBase < decimal.Zero)
{
formattedAttribute += string.Format(
await _localizationService.GetResourceAsync("FormattedAttributes.PriceAdjustment"),
"-", await _priceFormatter.FormatPriceAsync(-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(await _localizationService.GetResourceAsync("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(await _localizationService.GetResourceAsync("GiftCardAttribute.From.Virtual"), giftCardSenderName, giftCardSenderEmail) :
string.Format(await _localizationService.GetResourceAsync("GiftCardAttribute.From.Physical"), giftCardSenderName);
//recipient
var giftCardFor = product.GiftCardType == GiftCardType.Virtual ?
string.Format(await _localizationService.GetResourceAsync("GiftCardAttribute.For.Virtual"), giftCardRecipientName, giftCardRecipientEmail) :
string.Format(await _localizationService.GetResourceAsync("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>
/// Formats the price
/// </summary>
/// <param name="price">Price</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the price
/// </returns>
public virtual async Task <string> FormatPriceAsync(decimal price)
{
return(await FormatPriceAsync(price, true, await _workContext.GetWorkingCurrencyAsync()));
}
/// <summary>
/// Parse a customer entered price of the product
/// </summary>
/// <param name="product">Product</param>
/// <param name="form">Form</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the customer entered price of the product
/// </returns>
public virtual async Task <decimal> ParseCustomerEnteredPriceAsync(Product product, IFormCollection form)
{
if (product == null)
{
throw new ArgumentNullException(nameof(product));
}
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
var customerEnteredPriceConverted = decimal.Zero;
if (product.CustomerEntersPrice)
{
foreach (var formKey in form.Keys)
{
if (formKey.Equals($"addtocart_{product.Id}.CustomerEnteredPrice", StringComparison.InvariantCultureIgnoreCase))
{
if (decimal.TryParse(form[formKey], out var customerEnteredPrice))
{
customerEnteredPriceConverted = await _currencyService.ConvertToPrimaryStoreCurrencyAsync(customerEnteredPrice, await _workContext.GetWorkingCurrencyAsync());
}
break;
}
}
}
return(customerEnteredPriceConverted);
}
/// <summary>
/// Invokes the view component
/// </summary>
/// <param name="widgetZone">Widget zone name</param>
/// <param name="additionalData">Additional data</param>
/// <returns>The <see cref="Task"/> containing the <see cref="IViewComponentResult"/></returns>
public async Task <IViewComponentResult> InvokeAsync(string widgetZone, object additionalData)
{
if (!await _openPayService.CanDisplayWidgetAsync())
{
return(Content(string.Empty));
}
if (widgetZone == PublicWidgetZones.BodyEndHtmlTagBefore)
{
if (!_openPayPaymentSettings.DisplayLandingPageWidget)
{
return(Content(string.Empty));
}
return(View("~/Plugins/Payments.OpenPay/Views/Widget/LandingPageLink.cshtml"));
}
var region = Defaults.OpenPay.AvailableRegions.FirstOrDefault(
region => region.IsSandbox == _openPayPaymentSettings.UseSandbox && region.TwoLetterIsoCode == _openPayPaymentSettings.RegionTwoLetterIsoCode);
var workingCurrency = await _workContext.GetWorkingCurrencyAsync();
Task <decimal> toWorkingCurrencyAsync(decimal price) => _currencyService.ConvertFromPrimaryStoreCurrencyAsync(price, workingCurrency);
var model = new WidgetModel
{
WidgetCode = region.WidgetCode,
RegionCode = region.TwoLetterIsoCode,
CurrencyCode = workingCurrency.CurrencyCode,
CurrencyFormatting = workingCurrency.CustomFormatting,
PlanTiers = _openPayPaymentSettings.PlanTiers.Split(',').Select(x => int.Parse(x)).ToArray(),
MinEligibleAmount = await toWorkingCurrencyAsync(_openPayPaymentSettings.MinOrderTotal),
MaxEligibleAmount = await toWorkingCurrencyAsync(_openPayPaymentSettings.MaxOrderTotal),
Type = "Online"
};
if (widgetZone == PublicWidgetZones.ProductDetailsBottom && additionalData is ProductDetailsModel productDetailsModel)
{
if (!_openPayPaymentSettings.DisplayProductPageWidget)
{
return(Content(string.Empty));
}
var product = await _productService.GetProductByIdAsync(productDetailsModel.Id);
if (product == null || product.Deleted || product.IsDownload || !product.IsShipEnabled)
{
return(Content(string.Empty));
}
model.Logo = _openPayPaymentSettings.ProductPageWidgetLogo;
model.LogoPosition = _openPayPaymentSettings.ProductPageWidgetLogoPosition;
model.Amount = productDetailsModel.ProductPrice.PriceValue;
return(View("~/Plugins/Payments.OpenPay/Views/Widget/ProductPage.cshtml", model));
}
if (widgetZone == PublicWidgetZones.ProductBoxAddinfoMiddle && additionalData is ProductOverviewModel productOverviewModel)
{
if (!_openPayPaymentSettings.DisplayProductListingWidget)
{
return(Content(string.Empty));
}
var product = await _productService.GetProductByIdAsync(productOverviewModel.Id);
if (product == null || product.Deleted || product.IsDownload || !product.IsShipEnabled)
{
return(Content(string.Empty));
}
model.Logo = _openPayPaymentSettings.ProductListingWidgetLogo;
model.HideLogo = _openPayPaymentSettings.ProductListingHideLogo;
model.Amount = productOverviewModel.ProductPrice.PriceValue ?? decimal.Zero;
return(View("~/Plugins/Payments.OpenPay/Views/Widget/ProductListing.cshtml", model));
}
if (widgetZone == PublicWidgetZones.OrderSummaryContentAfter)
{
if (!_openPayPaymentSettings.DisplayCartWidget)
{
return(Content(string.Empty));
}
var routeName = HttpContext.GetEndpoint()?.Metadata.GetMetadata <RouteNameMetadata>()?.RouteName;
if (routeName != Defaults.ShoppingCartRouteName)
{
return(Content(string.Empty));
}
var customer = await _workContext.GetCurrentCustomerAsync();
var store = await _storeContext.GetCurrentStoreAsync();
var cart = await _shoppingCartService.GetShoppingCartAsync(customer, ShoppingCartType.ShoppingCart, store.Id);
if (cart == null || !cart.Any())
{
return(Content(string.Empty));
}
if (!await _shoppingCartService.ShoppingCartRequiresShippingAsync(cart))
{
return(Content(string.Empty));
}
var shoppingCartTotal = decimal.Zero;
var cartTotal = await _orderTotalCalculationService.GetShoppingCartTotalAsync(cart);
if (cartTotal.shoppingCartTotal.HasValue)
{
shoppingCartTotal = cartTotal.shoppingCartTotal.Value;
}
else
{
var cartSubTotal = await _orderTotalCalculationService.GetShoppingCartSubTotalAsync(cart, true);
shoppingCartTotal = cartSubTotal.subTotalWithDiscount;
}
model.Logo = _openPayPaymentSettings.CartWidgetLogo;
model.Amount = await toWorkingCurrencyAsync(shoppingCartTotal);
return(View("~/Plugins/Payments.OpenPay/Views/Widget/Cart.cshtml", model));
}
if (widgetZone == PublicWidgetZones.BodyStartHtmlTagAfter)
{
if (!_openPayPaymentSettings.DisplayInfoBeltWidget)
{
return(Content(string.Empty));
}
model.Color = _openPayPaymentSettings.InfoBeltWidgetColor;
return(View("~/Plugins/Payments.OpenPay/Views/Widget/InfoBelt.cshtml", model));
}
if (widgetZone == "OpenPayLandingPage")
{
if (!_openPayPaymentSettings.DisplayLandingPageWidget)
{
return(Content(string.Empty));
}
return(View("~/Plugins/Payments.OpenPay/Views/Widget/LandingPage.cshtml", model));
}
return(Content(string.Empty));
}