Dazzling.Studio.CheckoutService 1.0.6

IDEAL ING Bank

Get all the issuers

try
            {
                var ideal = cpm.PaymentMethods.Single(x => x.Name.Equals("ideal", StringComparison.InvariantCultureIgnoreCase));
                ServicePointManager.Expect100Continue = true;
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;                

                Connector connector = new Connector();
                connector.MerchantId = ideal["MerchantID"];
                connector.SubId = ideal["SubID"];
                connector.ExpirationPeriod = ideal["ExpirationPeriod"];
                connector.MerchantReturnUrl = new Uri(string.Format(ideal["MerchantReturnURL"], CurrentUser.LanguageCode));

                ING.iDealAdvanced.Data.Issuers issuers = connector.GetIssuerList();

                foreach (var country in issuers.Countries)
                {
                    foreach (var issuer in country.Issuers)
                    {
                        cpm.iDealIssuerList.Add(new SelectListItem() { Text = issuer.Name, Value = issuer.Id.ToString() });
                    }
                }
            }
            catch (ING.iDealAdvanced.Data.IDealException iex)
            {
                // request consumerMessage	
                MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).MailError(new HandleErrorInfo(iex, "CheckoutPaymentPage", "LoadIssueList")).SendAsync();
            }
            catch (Exception ex)
            {
                MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).MailError(new HandleErrorInfo(ex, "CheckoutPaymentPage", "LoadIssueList")).SendAsync();
                //throw;
            }

Mapping the CheckoutOrder object

static readonly IMapper OrderMapper;
        static CheckoutPageController()
        {
            var config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap<Order, CheckoutOrder>()
                  .ForMember(dest => dest.Company, opt => opt.MapFrom(src => SnuffoSettings.STORE_NAME))
                  .ForMember(dest => dest.OrderReference, opt => opt.MapFrom(src => src.OrderNumber))
                  .ForMember(dest => dest.IssuerId, opt => opt.MapFrom(src => src.MetaData))
                  .ForMember(dest => dest.PaymentMethod, opt => opt.MapFrom(src => string.Equals(src.PaymentMethod.Name, CS.PaymentMethod.iDEAL.ToString(), StringComparison.InvariantCultureIgnoreCase) ? CS.PaymentMethod.iDEAL : CS.PaymentMethod.PayPal))
                  .ForMember(dest => dest.OrderDate, opt => opt.MapFrom(src => src.OrderDate))
                  .ForMember(dest => dest.CallBackUrlOnPaymentSucceed, opt => opt.Ignore())
                  .ForMember(dest => dest.CallBackUrlOnPaymentFailed, opt => opt.Ignore())
                  .ForMember(dest => dest.Currency, opt => opt.MapFrom(src => SnuffoSettings.GetCurrency()))
                  .ForMember(dest => dest.ShippingFee, opt => opt.MapFrom(src => src.CalculateShippingFee()))
                  .ForMember(dest => dest.ServiceFee, opt => opt.MapFrom(src => src.CalculatePaymentFee()))
                  .ForMember(dest => dest.Subtotal, opt => opt.MapFrom(src => src.CalculateSubTotalWithoutVAT()))
                  .ForMember(dest => dest.Total, opt => opt.MapFrom(src => src.CalculateTotal()))
                  .ForMember(dest => dest.Discount, opt => opt.Ignore())
                  .ForMember(dest => dest.VAT, opt => opt.MapFrom(src => src.CalculateVAT()));

                cfg.CreateMap<ProductOrderDetail, CheckoutOrderDetail>()
                  .ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.Product.Sku))
                  .ForMember(dest => dest.Quantity, opt => opt.MapFrom(src => src.Quantity))
                  .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.Product.DisplayName(null)))
                  .ForMember(dest => dest.UnitPrice, opt => opt.MapFrom(src => src.CalculatePriceWithDiscount()));                

            OrderMapper = config.CreateMapper();
            //Mapper.AssertConfigurationIsValid();
        }

Checking out

try
            {
                var order = currentCart.GetOrder();

                var checkoutOrder = OrderMapper.Map<CheckoutOrder>(order);
                string baseUrl = WebUtils.GetApplicationUrlPath(HttpContext.ApplicationInstance.Context);
                checkoutOrder.CallBackUrlOnPaymentSucceed = $"{baseUrl}{CurrentUser.LanguageCode}/checkout-completed";
                checkoutOrder.CallBackUrlOnPaymentFailed = $"{baseUrl}{CurrentUser.LanguageCode}/checkout-cancelled";

                checkoutOrder.OrderDetails.AddRange(OrderMapper.Map<List<CheckoutOrderDetail>>(order.ProductOrderDetails));
                checkoutOrder.OrderDetails.AddRange(OrderMapper.Map<List<CheckoutOrderDetail>>(order.TicketOrderDetails));

                var payment = PaymentBase.CreatePayment(checkoutOrder);
                if (payment.PaymentMethod == CS.PaymentMethod.PayPal)
                {
                    PayPalPayment paypal = payment as PayPalPayment;
                    paypal.IsSandbox = string.Equals(order.PaymentMethod["Mode"], "sandbox");
                    paypal.ClientId = order.PaymentMethod["ClientId"];
                    paypal.ClientSecret = order.PaymentMethod["ClientSecret"];
                }

                if (Request.QueryString.Count == 0)
                {
                    var response = payment.DoPayment();
                    order.PaymentTransactionId = response.PaymentTransactionId;

                    // Save the order
                    currentCart.SaveOrder(order);

                    return Redirect(response.PaymentServiceUrl);
                }

                order.PayerId = Request.QueryString["PayerID"];
                if (payment.RequestPaymentStatus(order.PaymentTransactionId, order.PayerId, out string message) != PaymentStatus.Success)
                {
                    order.PaymentError = message;
                    // Save order
                    order.OrderStatusId = OrderStatus.Cancelled.Id;
                    currentCart.SaveOrder(order);

                    return Redirect($"/{CurrentUser.LanguageCode}/checkout-cancelled/");
                }
                // Tickets are sent immediately
                order.OrderStatusId = (order.ProductOrderDetails.IsNullOrEmpty()) ? OrderStatus.Sent.Id : OrderStatus.Started.Id;

                order.Paid = true;
                order.PaidAmount = order.CalculateTotal();

                currentCart.CompleteOrder(order);

                if (order.ProductOrderDetails.Any())
                {
                    // Send order confirmation mail.
                    MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).ConfirmOrderMail(order).Send();
                }
                if (order.TicketOrderDetails.Any()) // tickets bought
                {
                    MailController.Instance(Request, model.Content, CurrentUser.LanguageCode).SendTicketsPDF(order).Send();
                }
            }
            catch (OrderAlreadyProcessedException)
            {
                // Clear cart.
                currentCart.ClearCart();
            }