/// <summary>
/// Prepare payment method model
/// </summary>
/// <param name="cart">Cart</param>
/// <param name="filterByCountryId">Filter by country identifier</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the payment method model
/// </returns>
public virtual async Task <CheckoutPaymentMethodModel> PreparePaymentMethodModelAsync(IList <ShoppingCartItem> cart, int filterByCountryId)
{
var model = new CheckoutPaymentMethodModel();
//reward points
if (_rewardPointsSettings.Enabled && !await _shoppingCartService.ShoppingCartIsRecurringAsync(cart))
{
var rewardPointsBalance = await _rewardPointService.GetRewardPointsBalanceAsync((await _workContext.GetCurrentCustomerAsync()).Id, (await _storeContext.GetCurrentStoreAsync()).Id);
rewardPointsBalance = _rewardPointService.GetReducedPointsBalance(rewardPointsBalance);
var rewardPointsAmountBase = await _orderTotalCalculationService.ConvertRewardPointsToAmountAsync(rewardPointsBalance);
var rewardPointsAmount = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(rewardPointsAmountBase, await _workContext.GetWorkingCurrencyAsync());
if (rewardPointsAmount > decimal.Zero &&
_orderTotalCalculationService.CheckMinimumRewardPointsToUseRequirement(rewardPointsBalance))
{
model.DisplayRewardPoints = true;
model.RewardPointsAmount = await _priceFormatter.FormatPriceAsync(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 = !await _orderProcessingService.IsPaymentWorkflowRequiredAsync(cart, true);
}
}
//filter by country
var paymentMethods = await(await _paymentPluginManager
.LoadActivePluginsAsyncAsync(await _workContext.GetCurrentCustomerAsync(), (await _storeContext.GetCurrentStoreAsync()).Id, filterByCountryId))
.Where(pm => pm.PaymentMethodType == PaymentMethodType.Standard || pm.PaymentMethodType == PaymentMethodType.Redirection)
.WhereAwait(async pm => !await pm.HidePaymentMethodAsync(cart))
.ToListAsync();
foreach (var pm in paymentMethods)
{
if (await _shoppingCartService.ShoppingCartIsRecurringAsync(cart) && pm.RecurringPaymentType == RecurringPaymentType.NotSupported)
{
continue;
}
var pmModel = new CheckoutPaymentMethodModel.PaymentMethodModel
{
Name = await _localizationService.GetLocalizedFriendlyNameAsync(pm, (await _workContext.GetWorkingLanguageAsync()).Id),
Description = _paymentSettings.ShowPaymentMethodDescriptions ? await pm.GetPaymentMethodDescriptionAsync() : string.Empty,
PaymentMethodSystemName = pm.PluginDescriptor.SystemName,
LogoUrl = await _paymentPluginManager.GetPluginLogoUrlAsync(pm)
};
//payment method additional fee
var paymentMethodAdditionalFee = await _paymentService.GetAdditionalHandlingFeeAsync(cart, pm.PluginDescriptor.SystemName);
var(rateBase, _) = await _taxService.GetPaymentMethodAdditionalFeeAsync(paymentMethodAdditionalFee, await _workContext.GetCurrentCustomerAsync());
var rate = await _currencyService.ConvertFromPrimaryStoreCurrencyAsync(rateBase, await _workContext.GetWorkingCurrencyAsync());
if (rate > decimal.Zero)
{
pmModel.Fee = await _priceFormatter.FormatPaymentMethodAdditionalFeeAsync(rate, true);
}
model.PaymentMethods.Add(pmModel);
}
//find a selected (previously) payment method
var selectedPaymentMethodSystemName = await _genericAttributeService.GetAttributeAsync <string>(await _workContext.GetCurrentCustomerAsync(),
NopCustomerDefaults.SelectedPaymentMethodAttribute, (await _storeContext.GetCurrentStoreAsync()).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);
}
public override async Task <IActionResult> ConfirmOrder()
{
//validation
if (_orderSettings.CheckoutDisabled)
{
return(RedirectToRoute("ShoppingCart"));
}
var cart = await _shoppingCartService.GetShoppingCartAsync(
await _workContext.GetCurrentCustomerAsync(),
ShoppingCartType.ShoppingCart,
(await _storeContext.GetCurrentStoreAsync()).Id);
if (!cart.Any())
{
return(RedirectToRoute("ShoppingCart"));
}
if (_orderSettings.OnePageCheckoutEnabled)
{
return(RedirectToRoute("CheckoutOnePage"));
}
if (await _customerService.IsGuestAsync(await _workContext.GetCurrentCustomerAsync()) && !_orderSettings.AnonymousCheckoutAllowed)
{
return(Challenge());
}
await ValidateGiftCardAmountsAsync();
//model
var model = await _checkoutModelFactory.PrepareConfirmOrderModelAsync(cart);
try
{
//prevent 2 orders being placed within an X seconds time frame
if (!(await IsMinimumOrderPlacementIntervalValidAsync(await _workContext.GetCurrentCustomerAsync())))
{
throw new Exception(await _localizationService.GetResourceAsync("Checkout.MinOrderPlacementInterval"));
}
//place order
var processPaymentRequest = HttpContext.Session.Get <ProcessPaymentRequest>("OrderPaymentInfo");
if (processPaymentRequest == null)
{
//Check whether payment workflow is required
if (await _orderProcessingService.IsPaymentWorkflowRequiredAsync(cart))
{
return(RedirectToRoute("CheckoutPaymentInfo"));
}
processPaymentRequest = new ProcessPaymentRequest();
}
_paymentService.GenerateOrderGuid(processPaymentRequest);
processPaymentRequest.StoreId = (await _storeContext.GetCurrentStoreAsync()).Id;
processPaymentRequest.CustomerId = (await _workContext.GetCurrentCustomerAsync()).Id;
processPaymentRequest.PaymentMethodSystemName = await _genericAttributeService.GetAttributeAsync <string>(await _workContext.GetCurrentCustomerAsync(),
NopCustomerDefaults.SelectedPaymentMethodAttribute, (await _storeContext.GetCurrentStoreAsync()).Id);
HttpContext.Session.Set <ProcessPaymentRequest>("OrderPaymentInfo", processPaymentRequest);
// Set ABC custom values
var refNo = HttpContext.Session.GetString("Ref_No");
if (refNo != null)
{
processPaymentRequest.CustomValues.Add("CC_REFNO", refNo);
HttpContext.Session.Remove("Ref_No");
}
var authNo = HttpContext.Session.GetString("Auth_No");
if (authNo != null)
{
processPaymentRequest.CustomValues.Add("AuthCode", authNo);
HttpContext.Session.Remove("Auth_No");
}
var placeOrderResult = await _orderProcessingService.PlaceOrderAsync(processPaymentRequest);
if (placeOrderResult.Success)
{
HttpContext.Session.Set <ProcessPaymentRequest>("OrderPaymentInfo", null);
var postProcessPaymentRequest = new PostProcessPaymentRequest
{
Order = placeOrderResult.PlacedOrder
};
await _paymentService.PostProcessPaymentAsync(postProcessPaymentRequest);
if (_webHelper.IsRequestBeingRedirected || _webHelper.IsPostBeingDone)
{
//redirection or POST has been done in PostProcessPayment
return(Content(await _localizationService.GetResourceAsync("Checkout.RedirectMessage")));
}
return(RedirectToRoute("CheckoutCompleted", new { orderId = placeOrderResult.PlacedOrder.Id }));
}
foreach (var error in placeOrderResult.Errors)
{
model.Warnings.Add(error);
}
}
catch (Exception exc)
{
await _logger.WarningAsync(exc.Message, exc);
model.Warnings.Add(exc.Message);
}
//If we got this far, something failed, redisplay form
return(View(model));
}
