public ActionResult Purchase(CheckoutViewModel viewModel, IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel)
{
if (CartIsNullOrEmpty())
{
return(Redirect(Url.ContentUrl(ContentReference.StartPage)));
}
// Since the payment property is marked with an exclude binding attribute in the CheckoutViewModel
// it needs to be manually re-added again.
viewModel.Payment = paymentViewModel;
if (User.Identity.IsAuthenticated)
{
_checkoutService.CheckoutAddressHandling.UpdateAuthenticatedUserAddresses(viewModel);
var validation = _checkoutService.AuthenticatedPurchaseValidation;
if (!validation.ValidateModel(ModelState, viewModel) ||
!validation.ValidateOrderOperation(ModelState, _cartService.ValidateCart(Cart)) ||
!validation.ValidateOrderOperation(ModelState, _cartService.RequestInventory(Cart)))
{
return(View(viewModel));
}
}
else
{
_checkoutService.CheckoutAddressHandling.UpdateAnonymousUserAddresses(viewModel);
var validation = _checkoutService.AnonymousPurchaseValidation;
if (!validation.ValidateModel(ModelState, viewModel) ||
!validation.ValidateOrderOperation(ModelState, _cartService.ValidateCart(Cart)) ||
!validation.ValidateOrderOperation(ModelState, _cartService.RequestInventory(Cart)))
{
return(View(viewModel));
}
}
_checkoutService.UpdateShippingAddresses(Cart, viewModel);
_checkoutService.CreateAndAddPaymentToCart(Cart, viewModel);
var purchaseOrder = _checkoutService.PlaceOrder(Cart, ModelState, viewModel);
if (purchaseOrder == null)
{
return(View(viewModel));
}
var result = _klarnaPaymentsService.Complete(purchaseOrder);
if (result.IsRedirect)
{
Redirect(result.RedirectUrl);
}
var confirmationSentSuccessfully = _checkoutService.SendConfirmation(viewModel, purchaseOrder);
return(Redirect(_checkoutService.BuildRedirectionUrl(viewModel, purchaseOrder, confirmationSentSuccessfully)));
}
private void CreatePayment(IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel, AddressModel billingAddress)
{
IOrderAddress address = _addressBookService.ConvertToAddress(billingAddress);
var total = Cart.GetTotal(_orderGroupCalculator);
var payment = paymentViewModel.PaymentMethod.CreatePayment(total.Amount);
Cart.AddPayment(payment, _orderFactory);
payment.BillingAddress = address;
}
private void CreatePayment(IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel, AddressModel billingAddress)
{
IOrderAddress address = _addressBookService.ConvertToAddress(Cart, billingAddress);
var total = Cart.GetTotal(_orderGroupCalculator);
var payment = paymentViewModel.PaymentMethod.CreatePayment(Cart, total.Amount);
Cart.AddPayment(payment, _orderGroupFactory);
payment.BillingAddress = address;
if (Cart.IsQuoteCart())
{
payment.TransactionType = TransactionType.Capture.ToString();
}
}
private CheckoutViewModel CreateCheckoutViewModel(CheckoutPage currentPage, IPaymentMethodViewModel <PaymentMethodBase> paymentMethodViewModel)
{
return(new CheckoutViewModel
{
CurrentPage = currentPage,
Payment = paymentMethodViewModel,
UseBillingAddressForShipment = true,
Shipments = _cart.Forms.SelectMany(x => x.Shipments).Select(shipment => new ShipmentViewModel
{
ShipmentId = shipment.ShipmentId,
ShippingMethodId = shipment.ShippingMethodId
}).ToList(),
BillingAddress = new AddressModel
{
Email = "*****@*****.**"
}
});
}
public async Task <ActionResult> Index(CheckoutPage currentPage)
{
if (CartIsNullOrEmpty())
{
return(View("EmptyCart"));
}
IPaymentMethodViewModel <PaymentMethodBase> paymentMethod = null;
var selectedPaymentMethod = Request["paymentMethod"];
if (!string.IsNullOrEmpty(selectedPaymentMethod))
{
paymentMethod = PaymentMethodViewModelResolver.Resolve(selectedPaymentMethod);
paymentMethod.SystemName = selectedPaymentMethod;
}
var viewModel = CreateCheckoutViewModel(currentPage, paymentMethod);
Cart.Currency = _currencyService.GetCurrentCurrency();
if (User.Identity.IsAuthenticated)
{
_checkoutService.UpdateShippingAddresses(Cart, viewModel);
}
_checkoutService.UpdateShippingMethods(Cart, viewModel.Shipments);
_checkoutService.ApplyDiscounts(Cart);
_orderRepository.Save(Cart);
if (viewModel.Payment.SystemName.Equals(Klarna.Payments.Constants.KlarnaPaymentSystemKeyword))
{
await _klarnaPaymentsService.CreateOrUpdateSession(Cart);
(viewModel.Payment as KlarnaPaymentsViewModel)?.InitializeValues();
}
if (viewModel.Payment.SystemName.Equals(Klarna.Checkout.Constants.KlarnaCheckoutSystemKeyword))
{
_klarnaCheckoutService.CreateOrUpdateOrder(Cart);
(viewModel.Payment as KlarnaCheckoutViewModel)?.InitializeValues();
}
return(View(viewModel.ViewName, viewModel));
}
protected virtual async Task <IPaymentMethodViewModel> IsSavedCardUsedInRecurringOrders(
IPaymentMethodViewModel methodViewModel,
CultureInfo cultureInfo,
Guid customerId,
string scope)
{
if (methodViewModel is SavedCreditCardPaymentMethodViewModel vm)
{
vm.IsUsedInRecurringOrders = await RecurringOrderTemplatesViewService.GetIsPaymentMethodUsedInRecurringOrders(new GetIsPaymentMethodUsedInRecurringOrdersRequest
{
CultureInfo = cultureInfo,
CustomerId = customerId,
PaymentMethodId = methodViewModel.Id.ToString(),
ScopeId = scope
}).ConfigureAwait(false);
return(vm);
}
return(methodViewModel);
}
/// <summary>
/// Returns the fist payment non voided.
/// </summary>
protected virtual PaymentViewModel GetPaymentViewModel(
List <Payment> payments,
Address shippingAddress,
Dictionary <string, string> paymentMethodDisplayNames,
CultureInfo cultureInfo)
{
if (payments == null)
{
return(BuildEmptyPaymentViewModel());
}
var validPayments = payments.Where(x => !x.IsVoided()).ToList();
if (!validPayments.Any())
{
return(BuildEmptyPaymentViewModel());
}
var payment = validPayments.First();
IPaymentMethodViewModel paymentMethodViewModel = null;
if (payment.PaymentMethod != null)
{
paymentMethodViewModel = GetPaymentMethodViewModel(payment.PaymentMethod, paymentMethodDisplayNames, cultureInfo);
}
var billingAddressViewModel = GetBillingAddressViewModel(payment.BillingAddress, shippingAddress, cultureInfo);
return(new PaymentViewModel
{
Id = payment.Id,
IsLocked = payment.PaymentStatus != PaymentStatus.New && payment.PaymentStatus != PaymentStatus.PendingVerification,
PaymentMethod = paymentMethodViewModel,
PaymentStatus = payment.PaymentStatus,
BillingAddress = billingAddressViewModel
});
}
private CheckoutViewModel CreateCheckoutViewModel(CheckoutPage currentPage, IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel = null)
{
return(_checkoutViewModelFactory.CreateCheckoutViewModel(Cart, currentPage, paymentViewModel));
}
private ViewResult View(CheckoutViewModel checkoutViewModel, IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel)
{
return(View(checkoutViewModel.ViewName, CreateCheckoutViewModel(checkoutViewModel.CurrentPage, paymentViewModel)));
}
public ActionResult Purchase(CheckoutViewModel checkoutViewModel, IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel)
{
if (CartIsNullOrEmpty())
{
return(Redirect(Url.ContentUrl(ContentReference.StartPage)));
}
if (User.Identity.IsAuthenticated)
{
// load billing and shipping address from address book
_addressBookService.LoadAddress(checkoutViewModel.BillingAddress);
foreach (var shipment in checkoutViewModel.Shipments)
{
_addressBookService.LoadAddress(shipment.Address);
}
// Because address is selected from drop down, so remove validation for fields
foreach (var state in ModelState.Where(x => (x.Key.StartsWith("BillingAddress")) || x.Key.StartsWith("Shipments")).ToArray())
{
ModelState.Remove(state);
}
}
if (checkoutViewModel.UseBillingAddressForShipment)
{
// If only the billing address is of interest we need to remove any existing error related to the
// other shipping addresses.
if (!User.Identity.IsAuthenticated)
{
foreach (var state in ModelState.Where(x => x.Key.StartsWith("Shipments")).ToArray())
{
ModelState.Remove(state);
}
}
checkoutViewModel.Shipments.Single().Address = checkoutViewModel.BillingAddress;
}
ValidateBillingAddress(checkoutViewModel);
HandleValidationIssues(_cartService.ValidateCart(Cart));
if (!ModelState.IsValid)
{
return(View(checkoutViewModel, paymentViewModel));
}
// Since the payment property is marked with an exclude binding attribute in the CheckoutViewModel
// it needs to be manually re-added again.
checkoutViewModel.Payment = paymentViewModel;
ValidateShippingAddress(checkoutViewModel);
HandleValidationIssues(_cartService.RequestInventory(Cart));
if (!ModelState.IsValid)
{
return(View(checkoutViewModel, paymentViewModel));
}
UpdateAddressNames(checkoutViewModel);
SetShipmentAddresses(checkoutViewModel.Shipments);
CreatePayment(checkoutViewModel.Payment, checkoutViewModel.BillingAddress);
var startpage = _contentRepository.Get <StartPage>(ContentReference.StartPage);
var confirmationPage = _contentRepository.GetFirstChild <OrderConfirmationPage>(checkoutViewModel.CurrentPage.ContentLink);
IPurchaseOrder purchaseOrder = null;
try
{
purchaseOrder = PlaceOrder(checkoutViewModel);
}
catch (PaymentException)
{
ModelState.AddModelError("", _localizationService.GetString("/Checkout/Payment/Errors/ProcessingPaymentFailure"));
return(View(checkoutViewModel, paymentViewModel));
}
var queryCollection = new NameValueCollection
{
{ "contactId", _customerContext.CurrentContactId.ToString() },
{ "orderNumber", purchaseOrder.OrderLink.OrderGroupId.ToString(CultureInfo.CurrentCulture) }
};
SendConfirmationEmail(checkoutViewModel.BillingAddress.Email, startpage.OrderConfirmationMail, confirmationPage.Language.Name, queryCollection);
return(Redirect(new UrlBuilder(confirmationPage.LinkURL)
{
QueryCollection = queryCollection
}.ToString()));
}
public ActionResult Update(CheckoutPage currentPage, UpdateShippingMethodViewModel shipmentViewModel, IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel)
{
ModelState.Clear();
UpdateShippingMethodIds(Cart, shipmentViewModel.Shipments);
_orderRepository.Save(Cart);
var viewModel = CreateCheckoutViewModel(currentPage, paymentViewModel);
return(PartialView("Partial", viewModel));
}
private CheckoutViewModel CreateCheckoutViewModelWithAddressIds(CheckoutPage currentPage, IPaymentMethodViewModel <PaymentMethodBase> paymentMethodViewModel, bool useBillingAddressForShipment)
{
return(new CheckoutViewModel
{
CurrentPage = currentPage,
Payment = paymentMethodViewModel,
UseBillingAddressForShipment = useBillingAddressForShipment,
Shipments = _cart.Forms.SelectMany(x => x.Shipments).Select(shipment => new ShipmentViewModel
{
ShipmentId = shipment.ShipmentId,
ShippingMethodId = shipment.ShippingMethodId,
Address = new AddressModel()
{
AddressId = Guid.NewGuid().ToString()
}
}).ToList(),
BillingAddress = new AddressModel
{
AddressId = Guid.NewGuid().ToString(),
Email = "*****@*****.**"
}
});
}
protected virtual void IsCreditCardPaymentMethod(IPaymentMethodViewModel paymentMethod)
{
paymentMethod.IsCreditCardPaymentMethod = paymentMethod.PaymentProviderType == "MonerisCanadaPaymentProvider";
}
private CheckoutViewModel CreateCheckoutViewModelWithAddressIds(CheckoutPage currentPage, IPaymentMethodViewModel<PaymentMethodBase> paymentMethodViewModel, bool useBillingAddressForShipment)
{
return new CheckoutViewModel
{
CurrentPage = currentPage,
Payment = paymentMethodViewModel,
UseBillingAddressForShipment = useBillingAddressForShipment,
Shipments = _cart.Forms.SelectMany(x => x.Shipments).Select(shipment => new ShipmentViewModel
{
ShipmentId = shipment.ShipmentId,
ShippingMethodId = shipment.ShippingMethodId,
Address = new AddressModel()
{
AddressId = Guid.NewGuid().ToString()
}
}).ToList(),
BillingAddress = new AddressModel
{
AddressId = Guid.NewGuid().ToString(),
Email = "*****@*****.**"
}
};
}
public ActionResult Update(CheckoutPage currentPage, CheckoutViewModel viewModel, IPaymentMethodViewModel <IPaymentOption> paymentViewModel)
{
// Since the payment property is marked with an exclude binding attribute in the CheckoutViewModel
// it needs to be manually re-added again.
viewModel.Payment = paymentViewModel;
InitializeCheckoutViewModel(currentPage, viewModel);
IEnumerable <ShippingAddress> shippingAddresses = (viewModel.UseBillingAddressForShipment) ? new ShippingAddress[] { viewModel.BillingAddress } : viewModel.ShippingAddresses;
foreach (var shippingAddress in shippingAddresses)
{
var shipment = _checkoutService.CreateShipment();
var shippingMethods = _checkoutService.GetShippingRates(shipment);
var selectedShippingMethod = shippingMethods.FirstOrDefault(x => x.Id == shippingAddress.ShippingMethodId) ?? shippingMethods.First();
_checkoutService.UpdateShipment(shipment, selectedShippingMethod);
}
_cartService.RunWorkflow(OrderGroupWorkflowManager.CartValidateWorkflowName);
_cartService.SaveCart();
// Clearing the ModelState will remove any unwanted input validation errors in the new view.
ModelState.Clear();
return(PartialView("Partial", viewModel));
}
public async Task <ActionResult> Update(CheckoutPage currentPage, UpdateShippingMethodViewModel shipmentViewModel, IPaymentMethodViewModel <PaymentMethodBase> paymentViewModel, CheckoutViewModel inputModel)
{
ModelState.Clear();
_checkoutService.UpdateShippingMethods(Cart, shipmentViewModel.Shipments);
_checkoutService.ApplyDiscounts(Cart);
_orderRepository.Save(Cart);
var viewModel = CreateCheckoutViewModel(currentPage, paymentViewModel);
await _klarnaPaymentsService.CreateOrUpdateSession(Cart);
return(PartialView("Partial", viewModel));
}
public virtual CheckoutViewModel CreateCheckoutViewModel(ICart cart, CheckoutPage currentPage, IPaymentMethodViewModel<PaymentMethodBase> paymentViewModel = null)
{
if (cart == null)
{
return CreateEmptyCheckoutViewModel(currentPage);
}
var shipments = _shipmentViewModelFactory.CreateShipmentsViewModel(cart).ToList();
var viewModel = new CheckoutViewModel
{
CurrentPage = currentPage,
Shipments = shipments,
BillingAddress = CreateBillingAddressModel(),
UseBillingAddressForShipment = shipments.Count == 1 && _addressBookService.UseBillingAddressForShipment(),
StartPage = _contentLoader.Get<StartPage>(ContentReference.StartPage),
AppliedCouponCodes = cart.GetFirstForm().CouponCodes.Distinct(),
AvailableAddresses = new List<AddressModel>(),
ReferrerUrl = GetReferrerUrl(),
Payment = paymentViewModel,
};
UpdatePayment(viewModel);
var availableAddresses = GetAvailableAddresses();
if (availableAddresses.Any())
{
viewModel.AvailableAddresses.Add(new AddressModel { Name = _localizationService.GetString("/Checkout/MultiShipment/SelectAddress") });
foreach (var address in availableAddresses)
{
viewModel.AvailableAddresses.Add(address);
}
}
else
{
viewModel.AvailableAddresses.Add(new AddressModel { Name = _localizationService.GetString("/Checkout/MultiShipment/NoAddressFound") });
}
SetDefaultShipmentAddress(viewModel);
_addressBookService.LoadAddress(viewModel.BillingAddress);
PopulateCountryAndRegions(viewModel);
return viewModel;
}
protected virtual async Task <CheckoutPaymentViewModel> MapCheckoutPaymentViewModel(
Overture.ServiceModel.Orders.Cart cart,
List <IPaymentMethodViewModel> paymentMethodViewModels,
CultureInfo cultureInfo,
bool isAuthenticated)
{
var payment = GetActivePayment(cart);
if (payment == null)
{
return(null);
}
var paymentId = payment.Id;
IPaymentMethodViewModel activePaymentMethodVm = null;
ActivePaymentViewModel activePaymentVm = null;
if (payment.PaymentMethod != null)
{
activePaymentMethodVm = paymentMethodViewModels.FirstOrDefault(pm =>
pm.Id == payment.PaymentMethod.Id &&
pm.PaymentProviderName == payment.PaymentMethod.PaymentProviderName &&
pm.IsValid
);
}
if (activePaymentMethodVm != null)
{
var provider = PaymentProviderFactory.ResolveProvider(payment.PaymentMethod.PaymentProviderName);
activePaymentVm = GetActivePaymentViewModel(new GetActivePaymentViewModelParam
{
Cart = cart,
CultureInfo = cultureInfo,
PaymentProvider = provider,
IsAuthenticated = isAuthenticated
});
}
else
{
// If active payment is set to soemthing that doesn't exists anymore
// Select the first payment method available...
var validPaymentMethods = paymentMethodViewModels.Where(pm => pm.IsValid);
activePaymentMethodVm = validPaymentMethods.FirstOrDefault(pm => pm.Default) ?? validPaymentMethods.FirstOrDefault();
activePaymentVm = await UpdateActivePaymentMethodAsync(new UpdatePaymentMethodParam
{
CartName = cart.Name,
CultureInfo = cultureInfo,
CustomerId = cart.CustomerId,
IsAuthenticated = isAuthenticated,
Scope = cart.ScopeId,
PaymentId = paymentId,
PaymentMethodId = activePaymentMethodVm.Id,
PaymentProviderName = activePaymentMethodVm.PaymentProviderName,
}).ConfigureAwait(false);
if (activePaymentVm != null)
{
paymentId = activePaymentVm.Id;
}
}
if (activePaymentMethodVm != null)
{
activePaymentMethodVm.IsSelected = true;
}
var vm = new CheckoutPaymentViewModel
{
PaymentId = paymentId,
PaymentMethods = paymentMethodViewModels,
ActivePaymentViewModel = activePaymentVm
};
return(vm);
}
public ActionResult Purchase(CheckoutPage currentPage, CheckoutViewModel checkoutViewModel, IPaymentMethodViewModel <IPaymentOption> paymentViewModel)
{
// Since the payment property is marked with an exclude binding attribute in the CheckoutViewModel
// it needs to be manually re-added again.
checkoutViewModel.Payment = paymentViewModel;
if (String.IsNullOrEmpty(checkoutViewModel.BillingAddress.Email))
{
ModelState.AddModelError("BillingAddress.Email", _localizationService.GetString("/Shared/Address/Form/Empty/Email"));
}
if (checkoutViewModel.UseBillingAddressForShipment)
{
// If only the billing address is of interest we need to remove any existing error related to the
// other shipping addresses.
foreach (var state in ModelState.Where(x => x.Key.StartsWith("ShippingAddresses")).ToArray())
{
ModelState.Remove(state);
}
}
if (!ModelState.IsValid)
{
InitializeCheckoutViewModel(currentPage, checkoutViewModel);
return(View("Index", checkoutViewModel));
}
_checkoutService.ClearOrderAddresses();
// If the shipping address should be the same as the billing address, replace all existing shipping addresses to
// be the same as the billing address instead.
if (checkoutViewModel.UseBillingAddressForShipment)
{
checkoutViewModel.ShippingAddresses = new ShippingAddress[] { checkoutViewModel.BillingAddress };
}
SaveBillingAddress(checkoutViewModel);
SaveShippingAddresses(checkoutViewModel);
_cartService.RunWorkflow(OrderGroupWorkflowManager.CartPrepareWorkflowName);
_cartService.SaveCart();
try
{
_paymentService.ProcessPayment(checkoutViewModel.Payment.PaymentMethod);
}
catch (PreProcessException)
{
ModelState.AddModelError("PaymentMethod", _localizationService.GetString("/Checkout/Payment/Errors/PreProcessingFailure"));
}
if (!ModelState.IsValid)
{
InitializeCheckoutViewModel(currentPage, checkoutViewModel);
return(View("Index", checkoutViewModel));
}
return(Finish(currentPage));
}
private CheckoutViewModel CreateCheckoutViewModel(CheckoutPage currentPage, IPaymentMethodViewModel<PaymentMethodBase> paymentMethodViewModel)
{
return new CheckoutViewModel
{
CurrentPage = currentPage,
Payment = paymentMethodViewModel,
UseBillingAddressForShipment = true,
Shipments = _cart.Forms.SelectMany(x => x.Shipments).Select(shipment => new ShipmentViewModel
{
ShipmentId = shipment.ShipmentId,
ShippingMethodId = shipment.ShippingMethodId
}).ToList(),
BillingAddress = new AddressModel
{
Email = "*****@*****.**"
}
};
}
