/// <summary>
/// Prepare the customer reward points model
/// </summary>
/// <param name="page">Number of items page; pass null to load the first page</param>
/// <returns>Customer reward points model</returns>
public virtual CustomerRewardPointsModel PrepareCustomerRewardPoints(int?page)
{
//get reward points history
var customer = _workContext.CurrentCustomer;
var store = _storeContext.CurrentStore;
var pageSize = _rewardPointsSettings.PageSize;
var rewardPoints = _rewardPointService.GetRewardPointsHistory(customer.Id, store.Id, true, pageIndex: --page ?? 0, pageSize: pageSize);
//prepare model
var model = new CustomerRewardPointsModel
{
RewardPoints = rewardPoints.Select(historyEntry =>
{
var activatingDate = _dateTimeHelper.ConvertToUserTime(historyEntry.CreatedOnUtc, DateTimeKind.Utc);
return(new CustomerRewardPointsModel.RewardPointsHistoryModel
{
Points = historyEntry.Points,
PointsBalance = historyEntry.PointsBalance.HasValue ? historyEntry.PointsBalance.ToString()
: string.Format(_localizationService.GetResource("RewardPoints.ActivatedLater"), activatingDate),
Message = historyEntry.Message,
CreatedOn = activatingDate,
EndDate = !historyEntry.EndDateUtc.HasValue ? null :
(DateTime?)_dateTimeHelper.ConvertToUserTime(historyEntry.EndDateUtc.Value, DateTimeKind.Utc)
});
}).ToList(),
PagerModel = new PagerModel
{
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 = _rewardPointService.GetRewardPointsBalance(customer.Id, _storeContext.CurrentStore.Id);
var rewardPointsAmountBase = _orderTotalCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
var rewardPointsAmount = _currencyService.ConvertFromPrimaryStoreCurrency(rewardPointsAmountBase, _workContext.WorkingCurrency);
model.RewardPointsBalance = rewardPointsBalance;
model.RewardPointsAmount = _priceFormatter.FormatPrice(rewardPointsAmount, true, false);
//minimum amount/balance
var minimumRewardPointsBalance = _rewardPointsSettings.MinimumRewardPointsToUse;
var minimumRewardPointsAmountBase = _orderTotalCalculationService.ConvertRewardPointsToAmount(minimumRewardPointsBalance);
var minimumRewardPointsAmount = _currencyService.ConvertFromPrimaryStoreCurrency(minimumRewardPointsAmountBase, _workContext.WorkingCurrency);
model.MinimumRewardPointsBalance = minimumRewardPointsBalance;
model.MinimumRewardPointsAmount = _priceFormatter.FormatPrice(minimumRewardPointsAmount, true, false);
return(model);
}
public ActionResult CustomerRewardPoints(int?page)
{
if (!_workContext.CurrentCustomer.IsRegistered())
{
return(new HttpUnauthorizedResult());
}
if (!_rewardPointsSettings.Enabled)
{
return(RedirectToRoute("CustomerInfo"));
}
var customer = _workContext.CurrentCustomer;
var pageSize = _rewardPointsSettings.PageSize;
var model = new CustomerRewardPointsModel();
var list = _rewardPointService.GetRewardPointsHistory(customer.Id, pageIndex: --page ?? 0, pageSize: pageSize);
model.RewardPoints = list.Select(rph =>
new CustomerRewardPointsModel.RewardPointsHistoryModel
{
Points = rph.Points,
PointsBalance = rph.PointsBalance,
Message = rph.Message,
CreatedOn = _dateTimeHelper.ConvertToUserTime(rph.CreatedOnUtc, DateTimeKind.Utc)
}).ToList();
model.PagerModel = new PagerModel
{
PageSize = list.PageSize,
TotalRecords = list.TotalCount,
PageIndex = list.PageIndex,
ShowTotalSummary = true,
RouteActionName = "CustomerRewardPointsPaged",
UseRouteLinks = true,
RouteValues = new RewardPointsRouteValues {
page = page ?? 0
}
};
//current amount/balance
int rewardPointsBalance = _rewardPointService.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 CustomerRewardPointsModel PrepareCustomerRewardPoints(int?page)
{
var customer = _workContext.CurrentCustomer;
var pageSize = _rewardPointsSettings.PageSize;
var model = new CustomerRewardPointsModel();
var list = _rewardPointService.GetRewardPointsHistory(customer.Id, showNotActivated: true, pageIndex: --page ?? 0, pageSize: pageSize);
model.RewardPoints = list.Select(rph =>
{
var activatingDate = _dateTimeHelper.ConvertToUserTime(rph.CreatedOnUtc, DateTimeKind.Utc);
return(new CustomerRewardPointsModel.RewardPointsHistoryModel
{
Points = rph.Points,
PointsBalance = rph.PointsBalance.HasValue ? rph.PointsBalance.ToString()
: string.Format(_localizationService.GetResource("RewardPoints.ActivatedLater"), activatingDate),
Message = rph.Message,
CreatedOn = activatingDate
});
}).ToList();
model.PagerModel = new PagerModel
{
PageSize = list.PageSize,
TotalRecords = list.TotalCount,
PageIndex = list.PageIndex,
ShowTotalSummary = true,
RouteActionName = "CustomerRewardPointsPaged",
UseRouteLinks = true,
RouteValues = new RewardPointsRouteValues {
page = page ?? 0
}
};
//current amount/balance
int rewardPointsBalance = _rewardPointService.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(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 _rewardPointService.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 = _rewardPointService.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 IViewComponentResult Invoke(bool?prepareAndDisplayOrderReviewData, ShoppingCartModel overriddenModel)
{
ViewBag.BonusesBalance = _rewardPointService.GetRewardPointsBalance(_workContext.CurrentCustomer.Id, _storeContext.CurrentStore.Id);
//use already prepared (shared) model
if (overriddenModel != null)
{
return(View(overriddenModel));
}
//if not passed, then create a new model
var cart = _workContext.CurrentCustomer.ShoppingCartItems
.Where(sci => sci.ShoppingCartType == ShoppingCartType.ShoppingCart)
.LimitPerStore(_storeContext.CurrentStore.Id)
.ToList();
var model = new ShoppingCartModel();
model = _shoppingCartModelFactory.PrepareShoppingCartModel(model, cart,
isEditable: false,
prepareAndDisplayOrderReviewData: prepareAndDisplayOrderReviewData.GetValueOrDefault());
return(View(model));
}
/// <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 && !cart.IsRecurring())
{
int rewardPointsBalance = _rewardPointService.GetRewardPointsBalance(_workContext.CurrentCustomer.Id, _storeContext.CurrentStore.Id);
decimal rewardPointsAmountBase = _orderTotalCalculationService.ConvertRewardPointsToAmount(rewardPointsBalance);
decimal 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 (cart.IsRecurring() && pm.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
var pmModel = new CheckoutPaymentMethodModel.PaymentMethodModel
{
Name = pm.GetLocalizedFriendlyName(_localizationService, _workContext.WorkingLanguage.Id),
Description = _paymentSettings.ShowPaymentMethodDescriptions ? pm.PaymentMethodDescription : string.Empty,
PaymentMethodSystemName = pm.PluginDescriptor.SystemName,
LogoUrl = pm.PluginDescriptor.GetLogoUrl(_webHelper)
};
//payment method additional fee
decimal paymentMethodAdditionalFee = _paymentService.GetAdditionalHandlingFee(cart, pm.PluginDescriptor.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);
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);
}
/// <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="appliedDiscounts">Applied discounts</param>
/// <param name="redeemedRewardPoints">Reward points to redeem</param>
/// <param name="redeemedRewardPointsAmount">Reward points amount in primary store currency to redeem</param>
/// <param name="useRewardPoints">A value indicating reward points should be used; null to detect current choice of the customer</param>
/// <param name="usePaymentMethodAdditionalFee">A value indicating whether we should use payment method additional fee when calculating subscription 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 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,
_genericAttributeService,
_storeContext.CurrentStore.Id);
}
//subtotal without tax
decimal subscriptionSubTotalDiscountAmount;
decimal subTotalWithoutDiscountBase;
decimal subTotalWithDiscountBase;
GetShoppingCartSubTotal(cart, false,
out subscriptionSubTotalDiscountAmount,
out subTotalWithoutDiscountBase, out subTotalWithDiscountBase);
//subtotal with discount
decimal subtotalBase = subTotalWithDiscountBase;
//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);
//subscription total
decimal resultTemp = decimal.Zero;
resultTemp += subtotalBase;
resultTemp += paymentMethodAdditionalFeeWithoutTax;
resultTemp += shoppingCartTax;
if (_shoppingCartSettings.RoundPricesDuringCalculation)
{
resultTemp = RoundingHelper.RoundPrice(resultTemp);
}
#region Subscription total discount
discountAmount = GetSubscriptionTotalDiscount(customer, resultTemp);
//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
if (resultTemp < decimal.Zero)
{
resultTemp = decimal.Zero;
}
if (_shoppingCartSettings.RoundPricesDuringCalculation)
{
resultTemp = RoundingHelper.RoundPrice(resultTemp);
}
decimal subscriptionTotal = resultTemp;
#region Reward points
if (_rewardPointsSettings.Enabled)
{
if (!useRewardPoints.HasValue)
{
useRewardPoints = customer.GetAttribute <bool>(SystemCustomerAttributeNames.UseRewardPointsDuringCheckout, _genericAttributeService, _storeContext.CurrentStore.Id);
}
if (useRewardPoints.Value)
{
int rewardPointsBalance = _rewardPointService.GetRewardPointsBalance(customer.Id, _storeContext.CurrentStore.Id);
if (CheckMinimumRewardPointsToUseRequirement(rewardPointsBalance))
{
decimal rewardPointsBalanceAmount = ConvertRewardPointsToAmount(rewardPointsBalance);
if (subscriptionTotal > decimal.Zero)
{
if (subscriptionTotal > rewardPointsBalanceAmount)
{
redeemedRewardPoints = rewardPointsBalance;
redeemedRewardPointsAmount = rewardPointsBalanceAmount;
}
else
{
redeemedRewardPointsAmount = subscriptionTotal;
redeemedRewardPoints = ConvertAmountToRewardPoints(redeemedRewardPointsAmount);
}
}
}
}
}
#endregion
subscriptionTotal = subscriptionTotal - redeemedRewardPointsAmount;
if (_shoppingCartSettings.RoundPricesDuringCalculation)
{
subscriptionTotal = RoundingHelper.RoundPrice(subscriptionTotal);
}
return(subscriptionTotal);
}
