/// <summary>
        /// Successes the node URL.
        /// </summary>
        /// <param name="paymentProvider">The payment provider.</param>
        /// <returns></returns>
        /// <exception cref="System.Exception"></exception>
        public static string ReportUrl(this PaymentProvider paymentProvider)
        {
            var baseUrl = PaymentProviderHelper.GenerateBaseUrl();

            var paymentProviderRepositoryCmsNodeName = IO.Container.Resolve <ICMSApplication>().GetPaymentProviderRepositoryCMSNodeUrlName() ?? "PaymentProviders";
            var paymentProviderSectionCmsNodeName    = IO.Container.Resolve <ICMSApplication>().GetPaymentProviderSectionCMSNodeUrlName() ?? "PaymentProviders";
            var paymentProviderPath = string.Format("/{0}/{1}/", paymentProviderRepositoryCmsNodeName, paymentProviderSectionCmsNodeName);

            // http://domain.com/paymentproviders/payentproviders/ogone

            return(string.Format("{0}{1}{2}", baseUrl, paymentProviderPath, paymentProvider.Name));
        }
        public OrderInfo HandleuWebshopPaymentResponse(PaymentProvider paymentProvider, OrderInfo order)
        {
            if (paymentProvider.Name == null)
            {
                Log.Instance.LogError("HandleuWebshopPaymentRequest paymentProvider.Name == null paymentProviderNodeId: " + paymentProvider.Id);
                throw new Exception("HandleuWebshopPaymentRequest paymentProvider.Name == null");
            }

            var responsehandler = PaymentProviderHelper.GetAllPaymentResponseHandlers().FirstOrDefault(paymentResponseHandler => paymentResponseHandler.GetName().ToLower() == paymentProvider.Name.ToLower());

            if (responsehandler == null)
            {
                Log.Instance.LogError("HandleuWebshopPaymentRequest responsehandler == null paymentProvider.Name: " + paymentProvider.Name);

                throw new Exception("HandleuWebshopPaymentRequest responsehandler == null: " + paymentProvider.Name);
            }

            return(responsehandler.HandlePaymentResponse(paymentProvider, order));
        }
        /// <summary>
        /// Successes the node URL.
        /// </summary>
        /// <param name="paymentProvider">The payment provider.</param>
        /// <returns></returns>
        /// <exception cref="System.Exception"></exception>
        public static string CancelUrl(this PaymentProvider paymentProvider)
        {
            var baseUrl = PaymentProviderHelper.GenerateBaseUrl();

            var cancelNodeIdAsString = paymentProvider.CancelNodeId;

            int cancelNodeId;

            int.TryParse(cancelNodeIdAsString, out cancelNodeId);

            if (cancelNodeId != 0)
            {
                var cancelUrl = IO.Container.Resolve <ICMSApplication>().GetUrlForContentWithId(cancelNodeId);
                if (!cancelUrl.StartsWith("http"))
                {
                    cancelUrl = string.Format("{0}/{1}", baseUrl, cancelUrl.TrimStart('/'));
                }

                return(cancelUrl);
            }

            return(baseUrl);
        }
        /// <summary>
        /// Successes the node URL.
        /// </summary>
        /// <param name="paymentProvider">The payment provider.</param>
        /// <returns></returns>
        /// <exception cref="System.Exception"></exception>
        public static string ErrorUrl(this PaymentProvider paymentProvider)
        {
            var baseUrl = PaymentProviderHelper.GenerateBaseUrl();

            var successNodeIdAsString = paymentProvider.ErrorNodeId;

            int errorNodeId;

            int.TryParse(successNodeIdAsString, out errorNodeId);

            if (errorNodeId != 0)
            {
                var errorUrl = IO.Container.Resolve <ICMSApplication>().GetUrlForContentWithId(errorNodeId);
                if (!errorUrl.StartsWith("http"))
                {
                    errorUrl = string.Format("{0}/{1}", baseUrl, errorUrl.TrimStart('/'));
                }

                return(errorUrl);
            }

            return(baseUrl);
        }
Exemple #5
0
        /// <summary>
        /// Gets the redirect URL after confirmation.
        /// </summary>
        /// <param name="orderInfo">The order information.</param>
        /// <param name="confirmedNodeId">The confirmed node unique identifier.</param>
        /// <returns></returns>
        public static string HandlePaymentRequest(OrderInfo orderInfo, int confirmedNodeId)
        {
            var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id);

            var currentDomain = HttpContext.Current.Request.Url.Authority;

            if (paymentProvider != null)
            {
                Log.Instance.LogDebug("HandlePaymentRequest paymentProvider: " + paymentProvider.Title + " " + paymentProvider.Type);

                switch (paymentProvider.Type)
                {
                case PaymentProviderType.OfflinePaymentAtCustomer:
                case PaymentProviderType.OfflinePaymentInStore:
                    if (!string.IsNullOrEmpty(paymentProvider.SuccesNodeId))
                    {
                        int succesNodeId;

                        int.TryParse(paymentProvider.SuccesNodeId, out succesNodeId);

                        if (succesNodeId != 0)
                        {
                            var urlToReturn = IO.Container.Resolve <ICMSApplication>().GetUrlForContentWithId(succesNodeId);
                            if (!urlToReturn.ToString().ToLower().StartsWith("http"))
                            {
                                urlToReturn = string.Format("//{0}{1}", currentDomain, urlToReturn);
                            }
                            Log.Instance.LogDebug("HandlePaymentRequest SuccesNodeId: " + urlToReturn);

                            return(urlToReturn);
                        }
                    }
                    break;

                case PaymentProviderType.OnlinePayment:
                    var iPaymentProvider = PaymentProviderHelper.GetAllIPaymentProviders().FirstOrDefault(x => x.GetName().ToLowerInvariant() == paymentProvider.Name.ToLowerInvariant());

                    if (iPaymentProvider != null)
                    {
                        var handler = PaymentProviderHelper.GetAllPaymentRequestHandlers().FirstOrDefault(x => x.GetName().ToLowerInvariant() == paymentProvider.Name.ToLowerInvariant());

                        if (handler != null)
                        {
                            try
                            {
                                orderInfo.PaymentInfo.TransactionMethod = iPaymentProvider.GetParameterRenderMethod();
                                var handlerResult = handler.CreatePaymentRequest(orderInfo);
                                orderInfo.Save();

                                if (handlerResult == null)
                                {
                                    Log.Instance.LogError("HandlePaymentRequest handler.CreatePaymentRequest(orderInfo) == null");
                                    return("failed");
                                }
                            }
                            catch (Exception ex)
                            {
                                Log.Instance.LogError("HandlePaymentRequest handler.CreatePaymentRequest(orderInfo) FAILED " + ex);
                                return("failed");
                            }
                        }

                        switch (iPaymentProvider.GetParameterRenderMethod())
                        {
                        case PaymentTransactionMethod.Form:
                        case PaymentTransactionMethod.Custom:
                            if (!string.IsNullOrEmpty(paymentProvider.ControlNodeId))
                            {
                                int controlNodeId;

                                int.TryParse(paymentProvider.ControlNodeId, out controlNodeId);

                                if (controlNodeId != 0)
                                {
                                    string urlToReturn = IO.Container.Resolve <ICMSApplication>().GetUrlForContentWithId(controlNodeId);

                                    urlToReturn = string.Format("//{0}{1}", currentDomain, urlToReturn);

                                    Log.Instance.LogDebug("HandlePaymentRequest ControlNodeId: " + urlToReturn);
                                    return(urlToReturn);
                                }
                            }
                            Log.Instance.LogWarning("HandlePaymentRequest PaymentTransactionMethod.Form/Custom FAILED - paymentProvider.ControlNodeId not found: try fallback to orderInfo.PaymentInfo.Url");
                            if (!string.IsNullOrWhiteSpace(orderInfo.PaymentInfo.Url))
                            {
                                string value = string.Format("{0}{1}", orderInfo.PaymentInfo.Url, "?" + orderInfo.PaymentInfo.Parameters);

                                if (string.IsNullOrEmpty(orderInfo.PaymentInfo.Parameters))
                                {
                                    value = orderInfo.PaymentInfo.Url;
                                }

                                Log.Instance.LogDebug("HandlePaymentRequest PaymentTransactionMethod.QueryString: " + value);

                                return(value);
                            }
                            Log.Instance.LogWarning("HandlePaymentRequest PaymentTransactionMethod.Form/Custom FAILED");
                            return("failed");

                        case PaymentTransactionMethod.QueryString:
                            if (!string.IsNullOrWhiteSpace(orderInfo.PaymentInfo.Url))
                            {
                                string value = string.Format("{0}{1}", orderInfo.PaymentInfo.Url, "?" + orderInfo.PaymentInfo.Parameters);

                                if (string.IsNullOrEmpty(orderInfo.PaymentInfo.Parameters))
                                {
                                    value = orderInfo.PaymentInfo.Url;
                                }

                                Log.Instance.LogDebug("HandlePaymentRequest PaymentTransactionMethod.QueryString: " + value);

                                return(value);
                            }
                            Log.Instance.LogError("HandlePaymentRequest PaymentTransactionMethod.QueryString FAILED");
                            return("failed");

                        case PaymentTransactionMethod.ServerPost:

                            if (handler != null)
                            {
                                Log.Instance.LogDebug("HandlePaymentRequest paymentRequestHandlers.GetName(): " + handler.GetName());

                                string nextURL = handler.GetPaymentUrl(orderInfo);

                                Log.Instance.LogDebug("HandlePaymentRequest PaymentTransactionMethod.ServerPost nextURL: " + nextURL);


                                if (!string.IsNullOrEmpty(nextURL))
                                {
                                    Log.Instance.LogDebug("HandlePaymentRequest PaymentTransactionMethod.ServerPost nextURL: " + nextURL);

                                    return(nextURL);
                                }

                                Log.Instance.LogDebug("HandlePaymentRequest PaymentTransactionMethod.ServerPost OrderInfo.PaymentInfo.Url: " + orderInfo.PaymentInfo.Url);

                                if (!string.IsNullOrEmpty(orderInfo.PaymentInfo.Url))
                                {
                                    Log.Instance.LogDebug("HandlePaymentRequest PaymentTransactionMethod.ServerPost OrderInfo.PaymentInfo.Url: " + orderInfo.PaymentInfo.Url);

                                    return(orderInfo.PaymentInfo.Url);
                                }
                            }
                            Log.Instance.LogError("HandlePaymentRequest PaymentTransactionMethod.ServerPost FAILED: " + paymentProvider.Name);
                            return("failed");

                        case PaymentTransactionMethod.WebClient:
                            return("webclient");

                        case PaymentTransactionMethod.Inline:

                            if (handler != null)
                            {
                                return(handler.GetPaymentUrl(orderInfo));
                            }
                            return("inline");
                        }
                    }
                    Log.Instance.LogError("HandlePaymentRequest With Online Payment FAILED");
                    return("failed");
                }
            }

            if (confirmedNodeId != 0)
            {
                string confirmNodeId = confirmedNodeId != 0 ? IO.Container.Resolve <ICMSApplication>().GetUrlForContentWithId(confirmedNodeId) : string.Empty;

                confirmNodeId = string.Format("//{0}{1}", currentDomain, confirmNodeId);

                return(confirmNodeId);
            }

            string fallback = string.Format("//{0}", currentDomain);

            //Log.Instance.LogDebug( "HandlePaymentRequest fallback: " + fallback);

            return(fallback);
        }