public virtual async Task <CustomerRewardPointsModel> PrepareCustomerRewardPoints(Customer customer)
{
var model = new CustomerRewardPointsModel();
foreach (var rph in await _rewardPointsService.GetRewardPointsHistory(customer.Id))
{
model.RewardPoints.Add(new CustomerRewardPointsModel.RewardPointsHistoryModel
{
Points = rph.Points,
PointsBalance = rph.PointsBalance,
Message = rph.Message,
CreatedOn = _dateTimeHelper.ConvertToUserTime(rph.CreatedOnUtc, DateTimeKind.Utc)
});
}
//current amount/balance
int rewardPointsBalance = await _rewardPointsService.GetRewardPointsBalance(customer.Id, _storeContext.CurrentStore.Id);
decimal rewardPointsAmountBase = await _orderTotalCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
decimal rewardPointsAmount = await _currencyService.ConvertFromPrimaryStoreCurrency(rewardPointsAmountBase, _workContext.WorkingCurrency);
model.RewardPointsBalance = rewardPointsBalance;
model.RewardPointsAmount = _priceFormatter.FormatPrice(rewardPointsAmount, true, false);
//minimum amount/balance
int minimumRewardPointsBalance = _rewardPointsSettings.MinimumRewardPointsToUse;
decimal minimumRewardPointsAmountBase = await _orderTotalCalculationService.ConvertRewardPointsToAmount(minimumRewardPointsBalance);
decimal minimumRewardPointsAmount = await _currencyService.ConvertFromPrimaryStoreCurrency(minimumRewardPointsAmountBase, _workContext.WorkingCurrency);
model.MinimumRewardPointsBalance = minimumRewardPointsBalance;
model.MinimumRewardPointsAmount = _priceFormatter.FormatPrice(minimumRewardPointsAmount, true, false);
return(model);
}
public ActionResult CustomerRewardPoints()
{
if (!_workContext.CurrentCustomer.IsRegistered())
{
return(new HttpUnauthorizedResult());
}
if (!_rewardPointsSettings.Enabled)
{
return(RedirectToRoute("CustomerInfo"));
}
var customer = _workContext.CurrentCustomer;
var model = new CustomerRewardPointsModel();
foreach (var rph in _rewardPointsService.GetRewardPointsHistory(customer.Id))
{
model.RewardPoints.Add(new CustomerRewardPointsModel.RewardPointsHistoryModel
{
Points = rph.Points,
PointsBalance = rph.PointsBalance,
Message = rph.Message,
CreatedOn = _dateTimeHelper.ConvertToUserTime(rph.CreatedOnUtc, DateTimeKind.Utc)
});
}
//current amount/balance
int rewardPointsBalance = _rewardPointsService.GetRewardPointsBalance(customer.Id, _storeContext.CurrentStore.Id);
decimal rewardPointsAmountBase = _orderTotalCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
decimal rewardPointsAmount = _currencyService.ConvertFromPrimaryStoreCurrency(rewardPointsAmountBase, _workContext.WorkingCurrency);
model.RewardPointsBalance = rewardPointsBalance;
model.RewardPointsAmount = _priceFormatter.FormatPrice(rewardPointsAmount, true, false);
//minimum amount/balance
int minimumRewardPointsBalance = _rewardPointsSettings.MinimumRewardPointsToUse;
decimal minimumRewardPointsAmountBase = _orderTotalCalculationService.ConvertRewardPointsToAmount(minimumRewardPointsBalance);
decimal minimumRewardPointsAmount = _currencyService.ConvertFromPrimaryStoreCurrency(minimumRewardPointsAmountBase, _workContext.WorkingCurrency);
model.MinimumRewardPointsBalance = minimumRewardPointsBalance;
model.MinimumRewardPointsAmount = _priceFormatter.FormatPrice(minimumRewardPointsAmount, true, false);
return(View(model));
}
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 shopping cart total
/// </summary>
/// <param name="cart">Cart</param>
/// <param name="appliedGiftCards">Applied gift cards</param>
/// <param name="discountAmount">Applied discount amount</param>
/// <param name="appliedDiscount">Applied discount</param>
/// <param name="redeemedRewardPoints">Reward points to redeem</param>
/// <param name="redeemedRewardPointsAmount">Reward points amount in primary store currency to redeem</param>
/// <param name="ignoreRewardPonts">A value indicating whether we should ignore reward points (if enabled and a customer is going to use them)</param>
/// <param name="usePaymentMethodAdditionalFee">A value indicating whether we should use payment method additional fee when calculating order total</param>
/// <returns>Shopping cart total;Null if shopping cart total couldn't be calculated now</returns>
public virtual decimal?GetShoppingCartTotal(IList <ShoppingCartItem> cart,
out decimal discountAmount, out List <Discount> appliedDiscounts,
out List <AppliedGiftCard> appliedGiftCards,
out int redeemedRewardPoints, out decimal redeemedRewardPointsAmount,
bool?useRewardPoints = null, bool usePaymentMethodAdditionalFee = true)
{
redeemedRewardPoints = 0;
redeemedRewardPointsAmount = decimal.Zero;
var customer = cart.GetCustomer();
string paymentMethodSystemName = "";
if (customer != null)
{
paymentMethodSystemName = customer.GetAttribute <string>(
SystemCustomerAttributeNames.SelectedPaymentMethod,
_storeContext.CurrentStore.Id);
}
//subtotal without tax
decimal orderSubTotalDiscountAmount;
List <Discount> orderSubTotalAppliedDiscounts;
decimal subTotalWithoutDiscountBase;
decimal subTotalWithDiscountBase;
GetShoppingCartSubTotal(cart, false,
out orderSubTotalDiscountAmount, out orderSubTotalAppliedDiscounts,
out subTotalWithoutDiscountBase, out subTotalWithDiscountBase);
//subtotal with discount
decimal subtotalBase = subTotalWithDiscountBase;
//shipping without tax
decimal?shoppingCartShipping = GetShoppingCartShippingTotal(cart, false);
//payment method additional fee without tax
decimal paymentMethodAdditionalFeeWithoutTax = decimal.Zero;
if (usePaymentMethodAdditionalFee && !String.IsNullOrEmpty(paymentMethodSystemName))
{
decimal paymentMethodAdditionalFee = _paymentService.GetAdditionalHandlingFee(cart,
paymentMethodSystemName);
paymentMethodAdditionalFeeWithoutTax =
_taxService.GetPaymentMethodAdditionalFee(paymentMethodAdditionalFee,
false, customer);
}
//tax
decimal shoppingCartTax = GetTaxTotal(cart, usePaymentMethodAdditionalFee);
//order total
decimal resultTemp = decimal.Zero;
resultTemp += subtotalBase;
if (shoppingCartShipping.HasValue)
{
resultTemp += shoppingCartShipping.Value;
}
resultTemp += paymentMethodAdditionalFeeWithoutTax;
resultTemp += shoppingCartTax;
if (_shoppingCartSettings.RoundPricesDuringCalculation)
{
resultTemp = RoundingHelper.RoundPrice(resultTemp);
}
#region Order total discount
discountAmount = GetOrderTotalDiscount(customer, resultTemp, out appliedDiscounts);
//sub totals with discount
if (resultTemp < discountAmount)
{
discountAmount = resultTemp;
}
//reduce subtotal
resultTemp -= discountAmount;
if (resultTemp < decimal.Zero)
{
resultTemp = decimal.Zero;
}
if (_shoppingCartSettings.RoundPricesDuringCalculation)
{
resultTemp = RoundingHelper.RoundPrice(resultTemp);
}
#endregion
#region Applied gift cards
//let's apply gift cards now (gift cards that can be used)
appliedGiftCards = new List <AppliedGiftCard>();
if (!cart.IsRecurring())
{
//we don't apply gift cards for recurring products
var giftCards = _giftCardService.GetActiveGiftCardsAppliedByCustomer(customer);
if (giftCards != null)
{
foreach (var gc in giftCards)
{
if (resultTemp > decimal.Zero)
{
decimal remainingAmount = gc.GetGiftCardRemainingAmount();
decimal amountCanBeUsed = resultTemp > remainingAmount ?
remainingAmount :
resultTemp;
//reduce subtotal
resultTemp -= amountCanBeUsed;
var appliedGiftCard = new AppliedGiftCard();
appliedGiftCard.GiftCard = gc;
appliedGiftCard.AmountCanBeUsed = amountCanBeUsed;
appliedGiftCards.Add(appliedGiftCard);
}
}
}
}
#endregion
if (resultTemp < decimal.Zero)
{
resultTemp = decimal.Zero;
}
if (_shoppingCartSettings.RoundPricesDuringCalculation)
{
resultTemp = RoundingHelper.RoundPrice(resultTemp);
}
if (!shoppingCartShipping.HasValue)
{
//we have errors
return(null);
}
decimal orderTotal = resultTemp;
#region Reward points
if (_rewardPointsSettings.Enabled)
{
if (!useRewardPoints.HasValue)
{
useRewardPoints = customer.GetAttribute <bool>(SystemCustomerAttributeNames.UseRewardPointsDuringCheckout, _storeContext.CurrentStore.Id);
}
if (useRewardPoints.Value)
{
int rewardPointsBalance = _rewardPointsService.GetRewardPointsBalance(customer.Id, _storeContext.CurrentStore.Id);
if (CheckMinimumRewardPointsToUseRequirement(rewardPointsBalance))
{
decimal rewardPointsBalanceAmount = ConvertRewardPointsToAmount(rewardPointsBalance);
if (orderTotal > decimal.Zero)
{
if (orderTotal > rewardPointsBalanceAmount)
{
redeemedRewardPoints = rewardPointsBalance;
redeemedRewardPointsAmount = rewardPointsBalanceAmount;
}
else
{
redeemedRewardPointsAmount = orderTotal;
redeemedRewardPoints = ConvertAmountToRewardPoints(redeemedRewardPointsAmount);
}
}
}
}
}
#endregion
orderTotal = orderTotal - redeemedRewardPointsAmount;
if (_shoppingCartSettings.RoundPricesDuringCalculation)
{
orderTotal = RoundingHelper.RoundPrice(orderTotal);
}
return(orderTotal);
}