Exemplo n.º 1
0
        public override string GetCartNumber(HttpRequest request, IDictionary <string, string> settings)
        {
            string cartNumber = "";

            try
            {
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("paymentResponsePassword", "settings");

                //Write data when testing
                if (settings.ContainsKey("testMode") && settings["testMode"] == "100")
                {
                    LogRequest <WorldPay>(request, logPostData: true);
                }

                string paymentResponsePassword = settings["paymentResponsePassword"];
                string callbackPw = request.Form["callbackPW"];

                if (callbackPw == paymentResponsePassword)
                {
                    cartNumber = request.Form["cartId"];
                }
                else
                {
                    LoggingService.Instance.Warn <WorldPay>("WorldPay - Payment response password check failed - callbackPW: " + callbackPw + " - paymentResponsePassword: "******"WorldPay - Get cart number", exp);
            }

            return(cartNumber);
        }
Exemplo n.º 2
0
        public override string GetCancelUrl(Order order, IDictionary <string, string> settings)
        {
            settings.MustNotBeNull("settings");
            settings.MustContainKey("cancelURL", "settings");

            return(settings["cancelURL"]);
        }
Exemplo n.º 3
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "Vendor", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();

            inputFields[ "VPSProtocol" ] = "2.23";
            inputFields[ "TxType" ] = "CANCEL";
            inputFields[ "Vendor" ] = settings[ "Vendor" ];
            inputFields[ "VendorTxCode" ] = order.CartNumber;
            inputFields[ "VPSTxId" ] = order.TransactionInformation.TransactionId;
            inputFields[ "SecurityKey" ] = order.Properties[ "securityKey" ];

            IDictionary<string, string> responseFields = GetFields( MakePostRequest( GetMethodUrl( "CANCEL", settings ), inputFields ) );

            if ( responseFields[ "Status" ] == "OK" ) {
              apiInfo = new ApiInfo( order.TransactionInformation.TransactionId, PaymentState.Cancelled );
            } else {
              LoggingService.Instance.Log( "Sage pay(" + order.OrderNumber + ") - Error making API request: " + responseFields[ "StatusDetail" ] );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Sage pay(" + order.OrderNumber + ") - Cancel payment" );
              }

              return apiInfo;
        }
        public override string GetContinueUrl(Order order, IDictionary <string, string> settings)
        {
            settings.MustNotBeNull("settings");
            settings.MustContainKey("acceptUrl", "settings");

            return(settings["acceptUrl"]);
        }
Exemplo n.º 5
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "accountNumber", "settings" );
            settings.MustContainKey( "encryptionKey", "settings" );

            long accountNumber = long.Parse( settings[ "accountNumber" ] );
            int transactionNumber = int.Parse( order.TransactionInformation.TransactionId );

            string md5Hash = GenerateMD5Hash( accountNumber.ToString( CultureInfo.InvariantCulture ) + transactionNumber.ToString( CultureInfo.InvariantCulture ) + settings[ "encryptionKey" ] );

            XDocument xmlDoc = XDocument.Parse( GetPayExServiceClient( settings ).Cancel2( accountNumber, transactionNumber, md5Hash ), LoadOptions.PreserveWhitespace );
            string errorCode = xmlDoc.XPathSelectElement( "//status/errorCode" ).Value;

            if ( errorCode == "OK" && xmlDoc.XPathSelectElement( "//transactionStatus" ).Value == "4" ) {
              apiInfo = new ApiInfo( xmlDoc.XPathSelectElement( "//transactionNumber" ).Value, PaymentState.Cancelled );
            } else {
              LoggingService.Instance.Log( "PayEx(" + order.OrderNumber + ") - Error making API request - Error code: " + errorCode + " - Description: " + xmlDoc.XPathSelectElement( "//status/description" ).Value );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "PayEx(" + order.OrderNumber + ") - Cancel payment" );
              }

              return apiInfo;
        }
Exemplo n.º 6
0
        public override ApiInfo CancelPayment(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");

                IDictionary <string, string> inputFields = PrepareApiPostRequest("DoVoid", settings);

                inputFields.Add("AUTHORIZATIONID", order.TransactionInformation.TransactionId);

                ServicePointManager.SecurityProtocol = (SecurityProtocolType)3072;
                IDictionary <string, string> responseKvp = GetApiResponseKvp(MakePostRequest(settings.ContainsKey("isSandbox") && settings["isSandbox"] == "1" ? "https://api-3t.sandbox.paypal.com/nvp" : "https://api-3t.paypal.com/nvp", inputFields));
                if (responseKvp["ACK"] == "Success" || responseKvp["ACK"] == "SuccessWithWarning")
                {
                    apiInfo = InternalGetStatus(order.OrderNumber, responseKvp["AUTHORIZATIONID"], settings);
                }
                else
                {
                    LoggingService.Instance.Warn <PayPal>("PayPal(" + order.OrderNumber + ") - Error making API request - error code: " + responseKvp["L_ERRORCODE0"]);
                }
            } catch (Exception exp) {
                LoggingService.Instance.Error <PayPal>("PayPal(" + order.OrderNumber + ") - Cancel payment", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 7
0
        public override string GetContinueUrl( Order order, IDictionary<string, string> settings )
        {
            settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "merchant.confirmation_uri", "settings" );

              return settings[ "merchant.confirmation_uri" ];
        }
Exemplo n.º 8
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );

            IDictionary<string, string> inputFields = PrepareApiPostRequest( "DoVoid", settings );

            inputFields.Add( "AUTHORIZATIONID", order.TransactionInformation.TransactionId );

            ServicePointManager.SecurityProtocol = (SecurityProtocolType)3072;
            IDictionary<string, string> responseKvp = GetApiResponseKvp( MakePostRequest( settings.ContainsKey( "isSandbox" ) && settings[ "isSandbox" ] == "1" ? "https://api-3t.sandbox.paypal.com/nvp" : "https://api-3t.paypal.com/nvp", inputFields ) );
            if ( responseKvp[ "ACK" ] == "Success" || responseKvp[ "ACK" ] == "SuccessWithWarning" ) {
              apiInfo = InternalGetStatus( order.OrderNumber, responseKvp[ "AUTHORIZATIONID" ], settings );
            } else {
              LoggingService.Instance.Warn<PayPal>( "PayPal(" + order.OrderNumber + ") - Error making API request - error code: " + responseKvp[ "L_ERRORCODE0" ] );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Error<PayPal>( "PayPal(" + order.OrderNumber + ") - Cancel payment", exp );
              }

              return apiInfo;
        }
Exemplo n.º 9
0
        public override string GetContinueUrl( Order order, IDictionary<string, string> settings )
        {
            settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "acceptUrl", "settings" );

              return settings["acceptUrl"];
        }
Exemplo n.º 10
0
        public override string GetCancelUrl( Order order, IDictionary<string, string> settings )
        {
            settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "cancel_url", "settings" );

              return settings[ "cancel_url" ];
        }
Exemplo n.º 11
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "merchant", "settings" );
            settings.MustContainKey( "md5secret", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();

            inputFields[ "protocol" ] = "7";
            inputFields[ "msgtype" ] = "cancel";
            inputFields[ "merchant" ] = settings[ "merchant" ];
            inputFields[ "transaction" ] = order.TransactionInformation.TransactionId;

            string md5Secret = settings[ "md5secret" ];
            inputFields[ "md5check" ] = GenerateMD5Hash( string.Join( "", inputFields.Values ) + md5Secret );

            apiInfo = MakeApiPostRequest( order.OrderNumber, inputFields, md5Secret );
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "QuickPay(" + order.OrderNumber + ") - Cancel payment" );
              }

              return apiInfo;
        }
Exemplo n.º 12
0
        public override string GetCartNumber(HttpRequest request, IDictionary <string, string> settings)
        {
            string cartNumber = "";

            try
            {
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("mode", "settings");
                settings.MustContainKey(settings["mode"] + "_api_login_id", "settings");
                settings.MustContainKey(settings["mode"] + "_transaction_key", "settings");
                settings.MustContainKey(settings["mode"] + "_signature_key", "settings");

                // Write data when testing
                if (settings.ContainsKey("mode") && settings["mode"] == "sandbox")
                {
                    LogRequest <AuthorizeNet>(request, logPostData: true);
                }

                var authorizeNetEvent = GetValidatedWebhookEvent(settings[settings["mode"] + "_signature_key"]);
                if (authorizeNetEvent != null && authorizeNetEvent.eventType.StartsWith("net.authorize.payment."))
                {
                    var paymentPayload = authorizeNetEvent.payload.ToObject <AuthorizeNetWebhookPaymentPayload>();
                    if (paymentPayload != null && paymentPayload.entityName == "transaction")
                    {
                        var transactionId = paymentPayload.id;

                        // Configure AuthorizeNet
                        ConfigureAuthorizeNet(settings);

                        // Fetch the transaction
                        var transactionRequest = new getTransactionDetailsRequest {
                            transId = transactionId
                        };
                        var controller = new getTransactionDetailsController(transactionRequest);
                        controller.Execute();

                        var transactionResponse = controller.GetApiResponse();
                        if (transactionResponse != null &&
                            transactionResponse.messages.resultCode == messageTypeEnum.Ok &&
                            transactionResponse.transaction != null &&
                            transactionResponse.transaction.order != null)
                        {
                            // Stash the transaction
                            authorizeNetEvent.transaction = transactionResponse.transaction;

                            // Get the cart number
                            cartNumber = transactionResponse.transaction.order.invoiceNumber;
                        }
                    }
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <AuthorizeNet>("Authorize.net - GetCartNumber", exp);
            }

            return(cartNumber);
        }
Exemplo n.º 13
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try
            {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("secretKey", "settings");

                //Write data when testing
                if (settings.ContainsKey("testMode") && settings["testMode"] == "1")
                {
                    LogRequest <Paynova>(request, logPostData: true);
                }

                PostbackDigest postbackDigest = new PostbackDigest(settings["secretKey"]);
                if (order.CartNumber == request.Form["ORDER_NUMBER"] && postbackDigest.Validate(request.Form))
                {
                    decimal amountAuthorized  = decimal.Parse(request.Form["PAYMENT_1_AMOUNT"], CultureInfo.InvariantCulture);
                    string  transaction       = request.Form["PAYMENT_1_TRANSACTION_ID"];
                    string  paymentType       = request.Form["PAYMENT_1_PAYMENT_METHOD_NAME"];
                    string  paymentIdentifier = request.Form["PAYMENT_1_CARD_LAST_FOUR"];

                    PaymentState?paymentState = null;
                    switch (request.Form["PAYMENT_1_STATUS"])
                    {
                    case "Pending":
                        paymentState = PaymentState.PendingExternalSystem;
                        break;

                    case "Completed":
                    case "PartiallyCompleted":
                        paymentState = PaymentState.Captured;
                        break;

                    case "Authorized":
                        paymentState = PaymentState.Authorized;
                        break;
                    }

                    if (paymentState != null)
                    {
                        callbackInfo = new CallbackInfo(amountAuthorized, transaction, paymentState.Value, paymentType, paymentIdentifier);
                    }
                }
                else
                {
                    LoggingService.Instance.Warn <Paynova>("Paynova(" + order.CartNumber + ") - digest check failed");
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <Paynova>("Paynova(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 14
0
        public override ApiInfo RefundPayment(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("Vendor", "settings");
                settings.MustContainKey("Description", "settings");

                Dictionary <string, string> inputFields = new Dictionary <string, string>();

                Guid vendorTxCode = Guid.NewGuid();

                inputFields["VPSProtocol"]  = "2.23";
                inputFields["TxType"]       = "REFUND";
                inputFields["Vendor"]       = settings["Vendor"];
                inputFields["VendorTxCode"] = vendorTxCode.ToString();
                inputFields["Amount"]       = order.TransactionInformation.AmountAuthorized.Value.ToString("0.00", CultureInfo.InvariantCulture);
                //Check that the Iso code exists
                Currency currency = CurrencyService.Instance.Get(order.StoreId, order.CurrencyId);
                if (!Iso4217CurrencyCodes.ContainsKey(currency.IsoCode))
                {
                    throw new Exception("You must specify an ISO 4217 currency code for the " + currency.Name + " currency");
                }
                inputFields["Currency"]            = currency.IsoCode;
                inputFields["Description"]         = settings["Description"].Truncate(100);
                inputFields["RelatedVPSTxId"]      = order.TransactionInformation.TransactionId;
                inputFields["RelatedVendorTxCode"] = order.Properties["vendorTxCode"];
                inputFields["RelatedSecurityKey"]  = order.Properties["securityKey"];
                inputFields["RelatedTxAuthNo"]     = order.Properties["txAuthNo"];
                inputFields["ApplyAVSCV2"]         = "0";

                IDictionary <string, string> responseFields = GetFields(MakePostRequest(GetMethodUrl("REFUND", settings), inputFields));

                if (responseFields["Status"] == "OK")
                {
                    order.Properties.AddOrUpdate(new CustomProperty("vendorTxCode", vendorTxCode.ToString())
                    {
                        ServerSideOnly = true
                    });
                    order.Properties.AddOrUpdate(new CustomProperty("txAuthNo", responseFields["TxAuthNo"])
                    {
                        ServerSideOnly = true
                    });
                    order.Save();

                    apiInfo = new ApiInfo(responseFields["VPSTxId"], PaymentState.Refunded);
                }
                else
                {
                    LoggingService.Instance.Warn <SagePay>("Sage pay(" + order.OrderNumber + ") - Error making API request: " + responseFields["StatusDetail"]);
                }
            } catch (Exception exp) {
                LoggingService.Instance.Error <SagePay>("Sage pay(" + order.OrderNumber + ") - Refund payment", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 15
0
        protected string CreateSignature(IDictionary <string, string> fields, IDictionary <string, string> settings)
        {
            fields.MustNotBeNull("fields");
            settings.MustNotBeNull("settings");
            settings.MustContainKey("secret_key", "settings");

            return(new HMACSHA256(Encoding.UTF8.GetBytes(settings["secret_key"])).ComputeHash(Encoding.UTF8.GetBytes(string.Join(",", fields.Select(kvp => kvp.Key + "=" + kvp.Value)))).ToBase64());
        }
Exemplo n.º 16
0
        protected IPaynovaClient GetClient(IDictionary <string, string> settings)
        {
            settings.MustNotBeNull("settings");
            settings.MustContainKey("merchantId", "settings");
            settings.MustContainKey("apiPassword", "settings");

            return(new PaynovaClient(settings.ContainsKey("testMode") && settings["testMode"] == "1" ? "https://testapi.paynova.com/" : "https://api.paynova.com", settings["merchantId"], settings["apiPassword"]));
        }
Exemplo n.º 17
0
        public SettingsValidator(
            IUserConfig clusterProperties,
            FabricSettingsMetadata fabricSettingsMetadata,
            IDictionary <string, HashSet <string> > requiredParameters,
            ClusterManifestGeneratorSettings clusterManifestGeneratorSettings)
        {
            clusterProperties.MustNotBeNull("clusterProperties");
            requiredParameters.MustNotBeNull("fabricSettingsMetadata");
            requiredParameters.MustNotBeNull("requiredParameters");

            this.clusterProperties                = clusterProperties;
            this.fabricSettingsMetadata           = fabricSettingsMetadata;
            this.clusterManifestGeneratorSettings = clusterManifestGeneratorSettings;
            this.requiredParameters               = new Dictionary <string, HashSet <string> >(
                requiredParameters,
                StringComparer.OrdinalIgnoreCase);
        }
Exemplo n.º 18
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("privateKey", "settings");

                string orderName = order.CartNumber;
                while (orderName.Length < 4)
                {
                    orderName = "0" + orderName;
                }

                string checkSum = request.Headers["QuickPay-Checksum-Sha256"];

                byte[] bytes = new byte[request.InputStream.Length];
                request.InputStream.Read(bytes, 0, bytes.Length);
                request.InputStream.Position = 0;

                string streamContent = Encoding.ASCII.GetString(bytes);

                Result result = JsonConvert.DeserializeObject <Result>(streamContent);

                if (orderName == result.OrderId && GetChecksum(streamContent, settings["privateKey"]) == checkSum)
                {
                    Operation lastAuthorize = result.Operations.LastOrDefault(o => o.Type == "authorize");

                    if (lastAuthorize != null)
                    {
                        if (lastAuthorize.QpStatusCode == "20000")
                        {
                            decimal amount = decimal.Parse(lastAuthorize.Amount, CultureInfo.InvariantCulture) / 100M;

                            callbackInfo = new CallbackInfo(amount, result.Id, PaymentState.Authorized, result.Metadata.Type, result.Metadata.Last4);
                        }
                        else
                        {
                            LoggingService.Instance.Warn <QuickPay10>("Quickpay10(" + order.CartNumber + ") - Error making API request - error code: " + lastAuthorize.QpStatusCode + " | error message: " + lastAuthorize.QpStatusMsg);
                        }
                    }
                    else
                    {
                        LoggingService.Instance.Warn <QuickPay10>("QuickPay10(" + order.CartNumber + ") - No authorize found");
                    }
                }
                else
                {
                    LoggingService.Instance.Warn <QuickPay10>("QuickPay10(" + order.CartNumber + ") - Checksum security check failed");
                }
            } catch (Exception exp) {
                LoggingService.Instance.Error <QuickPay10>("QuickPay10(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 19
0
        public override ApiInfo GetStatus(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try
            {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("merchantId", "settings");
                settings.MustContainKey("token", "settings");

                Dictionary <string, string> inputFields = new Dictionary <string, string>();
                inputFields["merchantId"]    = settings["merchantId"];
                inputFields["token"]         = settings["token"];
                inputFields["transactionId"] = order.TransactionInformation.TransactionId;

                XDocument xmlResponse = QueryTransaction(order.TransactionInformation.TransactionId, settings);

                if (xmlResponse.XPathSelectElement("//PaymentInfo") != null)
                {
                    string transactionId = xmlResponse.XPathSelectElement("//PaymentInfo/TransactionId").Value;
                    bool   authorized    = bool.Parse(xmlResponse.XPathSelectElement("//PaymentInfo/Summary/Authorized").Value);
                    bool   cancelled     = bool.Parse(xmlResponse.XPathSelectElement("//PaymentInfo/Summary/Annulled").Value);
                    bool   captured      = decimal.Parse(xmlResponse.XPathSelectElement("//PaymentInfo/Summary/AmountCaptured").Value, CultureInfo.InvariantCulture) > 0;
                    bool   refunded      = decimal.Parse(xmlResponse.XPathSelectElement("//PaymentInfo/Summary/AmountCredited").Value, CultureInfo.InvariantCulture) > 0;

                    PaymentState paymentState = PaymentState.Initialized;
                    if (refunded)
                    {
                        paymentState = PaymentState.Refunded;
                    }
                    else if (captured)
                    {
                        paymentState = PaymentState.Captured;
                    }
                    else if (cancelled)
                    {
                        paymentState = PaymentState.Cancelled;
                    }
                    else if (authorized)
                    {
                        paymentState = PaymentState.Authorized;
                    }

                    apiInfo = new ApiInfo(transactionId, paymentState);
                }
                else
                {
                    LoggingService.Instance.Warn <Netaxept>("Netaxept(" + order.OrderNumber + ") - Error making API request - error message: " + xmlResponse.XPathSelectElement("//Error/Message").Value);
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <Netaxept>("Netaxept(" + order.OrderNumber + ") - Get status", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 20
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try
            {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("md5Key1", "settings");
                settings.MustContainKey("md5Key2", "settings");

                //Write data when testing
                if (settings.ContainsKey("test_mode") && settings["test_mode"] == "true")
                {
                    LogRequest <Payer>(request, logGetData: true);
                }

                //Check for payer IP addresses
                string remoteServerIpAddress = request.ServerVariables["REMOTE_ADDR"];

                if (remoteServerIpAddress == "217.151.207.84" || remoteServerIpAddress == "79.136.103.5" || remoteServerIpAddress == "79.136.103.9" || remoteServerIpAddress == "94.140.57.180" || remoteServerIpAddress == "94.140.57.181" || remoteServerIpAddress == "94.140.57.184" || remoteServerIpAddress == "192.168.100.1")
                {
                    string url             = request.Url.Scheme + "://" + request.Url.Host + request.ServerVariables["REQUEST_URI"];
                    string urlExceptMd5Sum = url.Substring(0, url.IndexOf("&md5sum", StringComparison.Ordinal));

                    string md5CheckValue = GenerateMD5Hash(settings["md5Key1"] + urlExceptMd5Sum + settings["md5Key2"]).ToUpperInvariant();

                    if (md5CheckValue == request.QueryString["md5sum"])
                    {
                        HttpContext.Current.Response.Output.Write("TRUE");

                        string       transaction  = request.QueryString["payread_payment_id"];
                        string       paymentType  = request.QueryString["payer_payment_type"];
                        string       callbackType = request.QueryString["payer_callback_type"];
                        PaymentState paymentState = callbackType == "auth" ? PaymentState.Authorized : PaymentState.Captured;

                        callbackInfo = new CallbackInfo(order.TotalPrice.Value.WithVat, transaction, paymentState, paymentType);
                    }
                    else
                    {
                        LoggingService.Instance.Warn <Payer>("Payer(" + order.CartNumber + ") - MD5Sum security check failed");
                    }
                }
                else
                {
                    LoggingService.Instance.Warn <Payer>("Payer(" + order.CartNumber + ") - IP security check failed - IP: " + remoteServerIpAddress);
                }

                HttpContext.Current.Response.Output.Write("FALSE");
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <Payer>("QuickPay(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
        public override ApiInfo CapturePayment(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try
            {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("Vendor", "settings");

                Dictionary <string, string> inputFields = new Dictionary <string, string>();

                Guid vendorTxCode = Guid.NewGuid();

                inputFields["VPSProtocol"]         = "2.23";
                inputFields["TxType"]              = "AUTHORISE";
                inputFields["Vendor"]              = settings["Vendor"];
                inputFields["VendorTxCode"]        = vendorTxCode.ToString();
                inputFields["Amount"]              = order.TransactionInformation.AmountAuthorized.Value.ToString("0.00", CultureInfo.InvariantCulture);
                inputFields["Description"]         = settings["Description"].Truncate(100);
                inputFields["RelatedVPSTxId"]      = order.TransactionInformation.TransactionId;
                inputFields["RelatedVendorTxCode"] = order.CartNumber;
                inputFields["RelatedSecurityKey"]  = order.Properties["securityKey"];
                inputFields["ApplyAVSCV2"]         = "0";

                IDictionary <string, string> responseFields = GetFields(MakePostRequest(GetMethodUrl("AUTHORISE", settings), inputFields));

                if (responseFields["Status"] == "OK")
                {
                    order.Properties.AddOrUpdate(new CustomProperty("vendorTxCode", vendorTxCode.ToString())
                    {
                        ServerSideOnly = true
                    });
                    order.Properties.AddOrUpdate(new CustomProperty("txAuthNo", responseFields["TxAuthNo"])
                    {
                        ServerSideOnly = true
                    });
                    order.Properties.AddOrUpdate(new CustomProperty("securityKey", responseFields["SecurityKey"])
                    {
                        ServerSideOnly = true
                    });
                    order.Save();

                    apiInfo = new ApiInfo(responseFields["VPSTxId"], PaymentState.Captured);
                }
                else
                {
                    LoggingService.Instance.Warn <SagePay>("Sage pay(" + order.OrderNumber + ") - Error making API request: " + responseFields["StatusDetail"]);
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <SagePay>("Sage pay(" + order.OrderNumber + ") - Cancel payment", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 22
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try
            {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");

                if (settings.ContainsKey("mode") && settings["mode"] == "test")
                {
                    LogRequest <CyberSource>(request, logPostData: true);
                }

                string calculatedSignature = CreateSignature(request.Form["signed_field_names"].Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToDictionary(k => k, k => request.Form[k]), settings);

                if (order.CartNumber == request.Form["reference_number"] && request.Form["signature"] == calculatedSignature)
                {
                    //Both errors and successful callbacks will go here

                    if (request.Form["decision"] == "ACCEPT")
                    {
                        callbackInfo = new CallbackInfo(decimal.Parse(request.Form["auth_amount"], CultureInfo.InvariantCulture), request.Form["transaction_id"], request.Form["req_transaction_type"] == "authorization" ? PaymentState.Authorized : PaymentState.Captured);

                        HttpContext.Current.Response.Redirect(order.Properties["teaCommerceContinueUrl"], false);
                    }
                    else
                    {
                        //Post interim form and auto submit it - act like the customer just clicked to the payment form page
                        if (order.PaymentInformation.PaymentMethodId != null)
                        {
                            // Pass through request fields
                            string requestFields = string.Join("", request.Form.AllKeys.Select(k => "<input type=\"hidden\" name=\"" + k + "\" value=\"" + request.Form[k] + "\" />"));
                            string paymentForm   = PaymentMethodService.Instance.Get(order.StoreId, order.PaymentInformation.PaymentMethodId.Value).GeneratePaymentForm(order, requestFields);

                            //Force the form to auto submit
                            paymentForm += "<script type=\"text/javascript\">document.forms[0].submit();</script>";

                            //Write out the form
                            HttpContext.Current.Response.Clear();
                            HttpContext.Current.Response.Write(paymentForm);
                        }
                    }
                }
                else
                {
                    LoggingService.Instance.Warn <CyberSource>("CyberSource(" + order.CartNumber + ") - Signature security check failed");
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <CyberSource>("CyberSource(" + order.CartNumber + ") - ProcessCallback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 23
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try
            {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("accountNumber", "settings");
                settings.MustContainKey("encryptionKey", "settings");

                long   accountNumber = long.Parse(settings["accountNumber"]);
                string orderRef      = order.Properties.First(p => p.Alias.Equals("orderRef")).Value;
                string md5Hash       = GenerateMD5Hash(accountNumber + orderRef + settings["encryptionKey"]);

                ServicePointManager.SecurityProtocol = (SecurityProtocolType)3072;
                string xmlReturn = GetPayExServiceClient(settings).Complete(accountNumber, orderRef, md5Hash);

                //Write data when testing
                if (settings.ContainsKey("testing") && settings["testing"] == "1")
                {
                    using (StreamWriter writer = new StreamWriter(File.Create(HostingEnvironment.MapPath("~/payex-callback-data.txt"))))
                    {
                        writer.WriteLine("Xml return:");
                        writer.WriteLine(xmlReturn);
                        writer.Flush();
                    }
                }

                XDocument xmlDoc            = XDocument.Parse(xmlReturn, LoadOptions.PreserveWhitespace);
                string    transactionStatus = xmlDoc.XPathSelectElement("//transactionStatus").Value;
                string    errorCode         = xmlDoc.XPathSelectElement("//status/errorCode").Value;

                //0 = Sale | 3 = Authorize
                if (errorCode == "OK" && (transactionStatus == "0" || transactionStatus == "3") && !bool.Parse(xmlDoc.XPathSelectElement("//alreadyCompleted").Value))
                {
                    decimal      amount            = decimal.Parse(xmlDoc.XPathSelectElement("//amount").Value, CultureInfo.InvariantCulture);
                    string       transactionNumber = xmlDoc.XPathSelectElement("//transactionNumber").Value;
                    PaymentState paymentState      = transactionStatus.Equals("3") ? PaymentState.Authorized : PaymentState.Captured;
                    string       paymentMethod     = xmlDoc.XPathSelectElement("//paymentMethod").Value;
                    string       maskedNumber      = xmlDoc.XPathSelectElement("//maskedNumber").Value;

                    callbackInfo = new CallbackInfo(amount / 100M, transactionNumber, paymentState, paymentMethod, maskedNumber);
                }
                else
                {
                    LoggingService.Instance.Warn <PayEx>("PayEx(" + order.CartNumber + ") - Callback failed - error code: " + errorCode + " - Description: " + xmlDoc.XPathSelectElement("//status/description").Value);
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <PayEx>("PayEx(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 24
0
        public override ApiInfo CapturePayment(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("merchant", "settings");
                settings.MustContainKey("md5k1", "settings");
                settings.MustContainKey("md5k2", "settings");

                Dictionary <string, string> inputFields = new Dictionary <string, string>();

                string merchant = settings["merchant"];
                inputFields["merchant"] = merchant;

                string strAmount = (order.TransactionInformation.AmountAuthorized.Value * 100M).ToString("0");
                inputFields["amount"] = strAmount;

                inputFields["orderid"]   = order.CartNumber;
                inputFields["transact"]  = order.TransactionInformation.TransactionId;
                inputFields["textreply"] = "yes";

                //MD5(key2 + MD5(key1 + “merchant=<merchant>&orderid=<orderid> &transact=<transact>&amount=<amount>"))
                string md5CheckValue = string.Empty;
                md5CheckValue += settings["md5k1"];
                md5CheckValue += "merchant=" + merchant;
                md5CheckValue += "&orderid=" + order.CartNumber;
                md5CheckValue += "&transact=" + order.TransactionInformation.TransactionId;
                md5CheckValue += "&amount=" + strAmount;

                inputFields["md5key"] = GenerateMD5Hash(settings["md5k2"] + GenerateMD5Hash(md5CheckValue));

                try {
                    string response = MakePostRequest("https://payment.architrade.com/cgi-bin/capture.cgi", inputFields);

                    Regex  reg    = new Regex(@"result=(\d*)");
                    string result = reg.Match(response).Groups[1].Value;

                    if (result == "0")
                    {
                        apiInfo = new ApiInfo(order.TransactionInformation.TransactionId, PaymentState.Captured);
                    }
                    else
                    {
                        LoggingService.Instance.Warn <Dibs>("DIBS(" + order.OrderNumber + ") - Error making API request - error message: " + result);
                    }
                } catch (WebException) {
                    LoggingService.Instance.Warn <Dibs>("DIBS(" + order.OrderNumber + ") - Error making API request - wrong credentials");
                }
            } catch (Exception exp) {
                LoggingService.Instance.Error <Dibs>("DIBS(" + order.OrderNumber + ") - Capture payment", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 25
0
        public override ApiInfo RefundPayment(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try
            {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("mode", "settings");
                settings.MustContainKey(settings["mode"] + "_api_login_id", "settings");
                settings.MustContainKey(settings["mode"] + "_transaction_key", "settings");

                // Configure AuthorizeNet
                ConfigureAuthorizeNet(settings);

                // Refund the transaction
                var transactionRequest = new createTransactionRequest
                {
                    transactionRequest = new transactionRequestType
                    {
                        transactionType = transactionTypeEnum.refundTransaction.ToString(),
                        amount          = ToTwoDecimalPlaces(order.TransactionInformation.AmountAuthorized.Value),
                        refTransId      = order.TransactionInformation.TransactionId,
                        payment         = new paymentType
                        {
                            Item = new creditCardType
                            {
                                cardNumber     = order.TransactionInformation.PaymentIdentifier.TrimStart('X'),
                                expirationDate = "XXXX"
                            }
                        }
                    }
                };

                var controller = new createTransactionController(transactionRequest);
                controller.Execute();

                var transactionResponse = controller.GetApiResponse();
                if (transactionResponse != null &&
                    transactionResponse.messages.resultCode == messageTypeEnum.Ok)
                {
                    apiInfo = new ApiInfo(order.TransactionInformation.TransactionId, PaymentState.Refunded);
                }
                else
                {
                    // Payment might not have settled yet so try canceling instead
                    return(CancelPayment(order, settings));
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <AuthorizeNet>("Authorize.net(" + order.OrderNumber + ") - RefundPayment", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 26
0
        public override ApiInfo GetStatus(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try
            {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("accountNumber", "settings");
                settings.MustContainKey("encryptionKey", "settings");

                long accountNumber     = long.Parse(settings["accountNumber"]);
                int  transactionNumber = int.Parse(order.TransactionInformation.TransactionId);

                string md5Hash = GenerateMD5Hash(accountNumber.ToString(CultureInfo.InvariantCulture) + transactionNumber.ToString(CultureInfo.InvariantCulture) + settings["encryptionKey"]);

                ServicePointManager.SecurityProtocol = (SecurityProtocolType)3072;
                XDocument xmlDoc    = XDocument.Parse(GetPayExServiceClient(settings).GetTransactionDetails2(accountNumber, transactionNumber, md5Hash), LoadOptions.PreserveWhitespace);
                string    errorCode = xmlDoc.XPathSelectElement("//status/errorCode").Value;

                if (errorCode == "OK")
                {
                    PaymentState paymentState = PaymentState.Initialized;
                    switch (xmlDoc.XPathSelectElement("//transactionStatus").Value)
                    {
                    case "3":
                        paymentState = PaymentState.Authorized;
                        break;

                    case "6":
                        paymentState = PaymentState.Captured;
                        break;

                    case "4":
                        paymentState = PaymentState.Cancelled;
                        break;

                    case "2":
                        paymentState = PaymentState.Refunded;
                        break;
                    }

                    apiInfo = new ApiInfo(xmlDoc.XPathSelectElement("//transactionNumber").Value, paymentState);
                }
                else
                {
                    LoggingService.Instance.Warn <PayEx>("PayEx(" + order.OrderNumber + ") - Error making API request - Error code: " + errorCode + " - Description: " + xmlDoc.XPathSelectElement("//status/description").Value);
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <PayEx>("PayEx(" + order.OrderNumber + ") - Get status", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 27
0
        protected Service GetAuthorizeNetServiceClient(IDictionary <string, string> settings)
        {
            settings.MustNotBeNull("settings");

            Service service = new Service {
                Url = settings.ContainsKey("testing") && settings["testing"] == "1" ? "https://apitest.authorize.net/soap/v1/Service.asmx" : "https://api.authorize.net/soap/v1/Service.asmx"
            };

            return(service);
        }
Exemplo n.º 28
0
        protected PxOrder GetPayExServiceClient(IDictionary <string, string> settings)
        {
            settings.MustNotBeNull("settings");

            PxOrder pxOrder = new PxOrder {
                Url = settings.ContainsKey("testing") && settings["testing"] == "1" ? "https://external.externaltest.payex.com/pxorder/pxorder.asmx" : "https://external.payex.com/pxorder/pxorder.asmx"
            };

            return(pxOrder);
        }
Exemplo n.º 29
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try
            {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("SHAOUTPASSPHRASE", "settings");

                //Write data when testing
                if (settings.ContainsKey("TESTMODE") && settings["TESTMODE"] == "1")
                {
                    LogRequest <Ogone>(request, logGetData: true);
                }

                Dictionary <string, string> inputFields = new Dictionary <string, string>();

                string shaSign     = request.QueryString["SHASIGN"];
                string strAmount   = request.QueryString["AMOUNT"];
                string transaction = request.QueryString["PAYID"];
                string status      = request.QueryString["STATUS"];
                string cardType    = request.QueryString["BRAND"];
                string cardNo      = request.QueryString["CARDNO"];

                foreach (string key in request.QueryString.Keys)
                {
                    if (!key.Equals("SHASIGN"))
                    {
                        inputFields[key] = request.QueryString[key];
                    }
                }

                string strToHash = string.Join("", inputFields.OrderBy(i => i.Key)
                                               .Where(i => !string.IsNullOrWhiteSpace(i.Value))
                                               .Select(i => i.Key.ToUpperInvariant() + "=" + i.Value + settings["SHAOUTPASSPHRASE"]));
                string digest = new SHA512Managed().ComputeHash(Encoding.UTF8.GetBytes(strToHash)).ToHex().ToUpperInvariant();

                if (order.CartNumber == request.QueryString["ORDERID"] && digest.Equals(shaSign))
                {
                    callbackInfo = new CallbackInfo(decimal.Parse(strAmount, CultureInfo.InvariantCulture), transaction, status == "5" || status == "51" ? PaymentState.Authorized : PaymentState.Captured, cardType, cardNo);
                }
                else
                {
                    LoggingService.Instance.Warn <Ogone>("Ogone(" + order.CartNumber + ") - SHASIGN check isn't valid - Calculated digest: " + digest + " - Ogone SHASIGN: " + shaSign);
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <Ogone>("Ogone(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 30
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("md5HashKey", "settings");
                settings.MustContainKey("x_login", "settings");

                //Write data when testing
                if (settings.ContainsKey("testing") && settings["testing"] == "1")
                {
                    LogRequest <AuthorizeNet>(request, logPostData: true);
                }

                string responseCode = request.Form["x_response_code"];
                if (responseCode == "1")
                {
                    string amount      = request.Form["x_amount"];
                    string transaction = request.Form["x_trans_id"];

                    string gatewayMd5Hash = request.Form["x_MD5_Hash"];

                    MD5CryptoServiceProvider x = new MD5CryptoServiceProvider();
                    string calculatedMd5Hash   = Regex.Replace(BitConverter.ToString(x.ComputeHash(Encoding.ASCII.GetBytes(settings["md5HashKey"] + settings["x_login"] + transaction + amount))), "-", string.Empty);

                    if (gatewayMd5Hash == calculatedMd5Hash)
                    {
                        PaymentState paymentState = PaymentState.Authorized;
                        if (request.Form["x_type"] == "auth_capture")
                        {
                            paymentState = PaymentState.Captured;
                        }
                        string cardType   = request.Form["x_card_type"];
                        string cardNumber = request.Form["x_account_number"];

                        callbackInfo = new CallbackInfo(decimal.Parse(amount, CultureInfo.InvariantCulture), transaction, paymentState, cardType, cardNumber);
                    }
                    else
                    {
                        LoggingService.Instance.Warn <AuthorizeNet>("Authorize.net(" + order.CartNumber + ") - MD5Sum security check failed - " + gatewayMd5Hash + " - " + calculatedMd5Hash + " - " + settings["md5HashKey"]);
                    }
                }
                else
                {
                    LoggingService.Instance.Warn <AuthorizeNet>("Authorize.net(" + order.CartNumber + ") - Payment not approved: " + responseCode);
                }
            } catch (Exception exp) {
                LoggingService.Instance.Error <AuthorizeNet>("Authorize.net(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 31
0
        public override ApiInfo GetStatus(Order order, IDictionary <string, string> settings)
        {
            ApiInfo apiInfo = null;

            try
            {
                order.MustNotBeNull("order");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("apiusername", "settings");
                settings.MustContainKey("apipassword", "settings");

                Dictionary <string, string> inputFields = new Dictionary <string, string>();

                try
                {
                    string response = MakePostRequest("https://@payment.architrade.com/cgi-adm/payinfo.cgi?transact=" + order.TransactionInformation.TransactionId, inputFields, new NetworkCredential(settings["apiusername"], settings["apipassword"]));

                    Regex  regex  = new Regex(@"status=(\d+)");
                    string status = regex.Match(response).Groups[1].Value;

                    PaymentState paymentState = PaymentState.Initialized;

                    switch (status)
                    {
                    case "2":
                        paymentState = PaymentState.Authorized;
                        break;

                    case "5":
                        paymentState = PaymentState.Captured;
                        break;

                    case "6":
                        paymentState = PaymentState.Cancelled;
                        break;

                    case "11":
                        paymentState = PaymentState.Refunded;
                        break;
                    }

                    apiInfo = new ApiInfo(order.TransactionInformation.TransactionId, paymentState);
                }
                catch (WebException)
                {
                    LoggingService.Instance.Warn <Dibs>("DIBS(" + order.OrderNumber + ") - Error making API request - wrong credentials");
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <Dibs>("DIBS(" + order.OrderNumber + ") - Get status", exp);
            }

            return(apiInfo);
        }
Exemplo n.º 32
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");

                //Write data when testing
                if (settings.ContainsKey("testMode") && settings["testMode"] == "1")
                {
                    LogRequest <ePay>(request, logGetData: true);
                }

                string transaction = request.QueryString["txnid"];
                string strAmount   = request.QueryString["amount"];
                string hash        = request.QueryString["hash"];

                string md5CheckValue = string.Empty;

                foreach (string k in request.QueryString.Keys)
                {
                    if (k != "hash")
                    {
                        md5CheckValue += request.QueryString[k];
                    }
                }
                if (settings.ContainsKey("md5securitykey"))
                {
                    md5CheckValue += settings["md5securitykey"];
                }

                if (order.CartNumber == request.QueryString["orderid"] && GenerateMD5Hash(md5CheckValue) == hash)
                {
                    string fee           = request.QueryString["txnfee"];
                    string cardid        = request.QueryString["paymenttype"];
                    string cardnopostfix = request.QueryString["cardno"];

                    decimal totalAmount = (decimal.Parse(strAmount, CultureInfo.InvariantCulture) + decimal.Parse(fee, CultureInfo.InvariantCulture));

                    bool autoCaptured = settings.ContainsKey("instantcapture") && settings["instantcapture"] == "1";

                    callbackInfo = new CallbackInfo(totalAmount / 100M, transaction, !autoCaptured ? PaymentState.Authorized : PaymentState.Captured, cardid, cardnopostfix);
                }
                else
                {
                    LoggingService.Instance.Warn <ePay>("ePay(" + order.CartNumber + ") - MD5Sum security check failed");
                }
            } catch (Exception exp) {
                LoggingService.Instance.Error <ePay>("ePay(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 33
0
        protected Dictionary <string, string> MakeNVPGatewayRequest(string operation, IDictionary <string, string> inputFields, IDictionary <string, string> settings)
        {
            Dictionary <string, string> response = new Dictionary <string, string>();

            settings.MustNotBeNull("settings");
            settings.MustContainKey("brq_websitekey", "settings");
            settings.MustContainKey("secret_key", "settings");
            settings.MustContainKey("test_mode", "settings");

            try
            {
                // prepare request
                inputFields["brq_signature"] = GenerateBuckarooSignature(inputFields, settings);

                // prepare response
                string brq_signature = "";
                Dictionary <string, string> nvpResponse = new Dictionary <string, string>();

                string nvpAll = MakePostRequest(GetNvpMethodUrl(settings) + "?op=" + operation, inputFields);

                if (!(nvpAll.Contains("BRQ_APIRESULT") && nvpAll.Contains("Fail")))
                {
                    foreach (string nvp in nvpAll.Split('&'))
                    {
                        string key   = nvp.Split('=')[0];
                        string value = HttpUtility.UrlDecode(nvp.Split('=')[1]);

                        if (!key.Equals("BRQ_SIGNATURE"))
                        {
                            nvpResponse.Add(key, value);
                        }
                        else
                        {
                            brq_signature = value;
                        }
                    }

                    if (GenerateBuckarooSignature(nvpResponse, settings).Equals(brq_signature))
                    {
                        return(nvpResponse);
                    }
                    else
                    {
                        LoggingService.Instance.Info <BuckarooPayments>("Buckaroo-Payments MakeNVPGatewayRequest: Invalid Signature");
                    }
                }
            }
            catch (Exception e)
            {
                LoggingService.Instance.Error <BuckarooPayments>(String.Concat("Buckaroo-Payments MakeNVPGatewayRequest response: ", response), e);
            }

            return(response);
        }
Exemplo n.º 34
0
        public override PaymentHtmlForm GenerateHtmlForm(Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary <string, string> settings)
        {
            order.MustNotBeNull("order");
            settings.MustNotBeNull("settings");
            settings.MustContainKey("form_url", "settings");
            settings.MustContainKey("mode", "settings");
            settings.MustContainKey(settings["mode"] + "_public_key", "settings");

            var htmlForm = new PaymentHtmlForm
            {
                Action = settings["form_url"]
            };

            // Copy all settings except those in default settings list
            // as all default settings are handled explicitly below
            htmlForm.InputFields = settings.Where(i => !DefaultSettings.ContainsKey(i.Key)).ToDictionary(i => i.Key, i => i.Value);

            htmlForm.InputFields["api_key"]      = settings[settings["mode"] + "_public_key"];
            htmlForm.InputFields["continue_url"] = teaCommerceContinueUrl;
            htmlForm.InputFields["cancel_url"]   = teaCommerceCancelUrl;

            if (settings.ContainsKey("billing_address_line1_property_alias") && !string.IsNullOrWhiteSpace(settings["billing_address_line1_property_alias"]))
            {
                htmlForm.InputFields["billing_address_line1"] = order.Properties.First(x => x.Alias == settings["billing_address_line1_property_alias"]).Value;
            }

            if (settings.ContainsKey("billing_address_line2_property_alias") && !string.IsNullOrWhiteSpace(settings["billing_address_line2_property_alias"]))
            {
                htmlForm.InputFields["billing_address_line2"] = order.Properties.First(x => x.Alias == settings["billing_address_line2_property_alias"]).Value;
            }

            if (settings.ContainsKey("billing_city_property_alias") && !string.IsNullOrWhiteSpace(settings["billing_city_property_alias"]))
            {
                htmlForm.InputFields["billing_city"] = order.Properties.First(x => x.Alias == settings["billing_city_property_alias"]).Value;
            }

            if (settings.ContainsKey("billing_state_property_alias") && !string.IsNullOrWhiteSpace(settings["billing_state_property_alias"]))
            {
                htmlForm.InputFields["billing_state"] = order.Properties.First(x => x.Alias == settings["billing_state_property_alias"]).Value;
            }

            if (settings.ContainsKey("billing_zip_code_property_alias") && !string.IsNullOrWhiteSpace(settings["billing_zip_code_property_alias"]))
            {
                htmlForm.InputFields["billing_zip_code"] = order.Properties.First(x => x.Alias == settings["billing_zip_code_property_alias"]).Value;
            }

            if (order.PaymentInformation != null && order.PaymentInformation.CountryId > 0)
            {
                var country = CountryService.Instance.Get(order.StoreId, order.PaymentInformation.CountryId);
                htmlForm.InputFields["billing_country"] = country.RegionCode.ToLowerInvariant();
            }

            return(htmlForm);
        }
Exemplo n.º 35
0
        public override string GetCancelUrl(Order order, IDictionary <string, string> settings)
        {
            settings.MustNotBeNull("settings");
            settings.MustContainKey("return_cancel_url", "settings");

            // WARN: this gets the URL of the current path as a base path. So you can use relative URL's to the language node of the site.
            string path    = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority);
            string baseUrl = path + String.Concat(HttpContext.Current.Request.Url.Segments.Take(2));

            return(GetAbsoluteUrl(baseUrl, settings["return_cancel_url"]));
        }
Exemplo n.º 36
0
        public override CallbackInfo ProcessCallback(Order order, HttpRequest request, IDictionary <string, string> settings)
        {
            CallbackInfo callbackInfo = null;

            try
            {
                order.MustNotBeNull("order");
                request.MustNotBeNull("request");
                settings.MustNotBeNull("settings");
                settings.MustContainKey("md5k1", "settings");
                settings.MustContainKey("md5k2", "settings");

                //Write data when testing
                if (settings.ContainsKey("test") && settings["test"] == "1")
                {
                    LogRequest <Dibs>(request, logPostData: true);
                }

                string transaction  = request.Form["transact"];
                string currencyCode = request.Form["currency"];
                string strAmount    = request.Form["amount"];
                string authkey      = request.Form["authkey"];
                string capturenow   = request.Form["capturenow"];
                string fee          = request.Form["fee"] ?? "0"; //Is not always in the return data
                string paytype      = request.Form["paytype"];
                string cardnomask   = request.Form["cardnomask"];

                decimal totalAmount  = (decimal.Parse(strAmount, CultureInfo.InvariantCulture) + decimal.Parse(fee, CultureInfo.InvariantCulture));
                bool    autoCaptured = capturenow == "1";

                string md5CheckValue = string.Empty;
                md5CheckValue += settings["md5k1"];
                md5CheckValue += "transact=" + transaction;
                md5CheckValue += "&amount=" + totalAmount.ToString("0", CultureInfo.InvariantCulture);
                md5CheckValue += "&currency=" + currencyCode;

                //authkey = MD5(k2 + MD5(k1 + "transact=tt&amount=aa&currency=cc"))
                if (GenerateMD5Hash(settings["md5k2"] + GenerateMD5Hash(md5CheckValue)) == authkey)
                {
                    callbackInfo = new CallbackInfo(totalAmount / 100M, transaction, !autoCaptured ? PaymentState.Authorized : PaymentState.Captured, paytype, cardnomask);
                }
                else
                {
                    LoggingService.Instance.Warn <Dibs>("DIBS(" + order.CartNumber + ") - MD5Sum security check failed");
                }
            }
            catch (Exception exp)
            {
                LoggingService.Instance.Error <Dibs>("DIBS(" + order.CartNumber + ") - Process callback", exp);
            }

            return(callbackInfo);
        }
Exemplo n.º 37
0
        protected pgwapi GetWannafindServiceClient(IDictionary <string, string> settings)
        {
            settings.MustNotBeNull("settings");
            settings.MustContainKey("apiUser", "settings");
            settings.MustContainKey("apiPassword", "settings");

            pgwapi paymentGateWayApi = new pgwapi {
                Credentials = new NetworkCredential(settings["apiUser"], settings["apiPassword"])
            };

            return(paymentGateWayApi);
        }
Exemplo n.º 38
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "merchant", "settings" );
            settings.MustContainKey( "md5k1", "settings" );
            settings.MustContainKey( "md5k2", "settings" );
            settings.MustContainKey( "apiusername", "settings" );
            settings.MustContainKey( "apipassword", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();

            string merchant = settings[ "merchant" ];
            inputFields[ "merchant" ] = merchant;

            inputFields[ "orderid" ] = order.CartNumber;
            inputFields[ "transact" ] = order.TransactionInformation.TransactionId;
            inputFields[ "textreply" ] = "yes";

            //MD5(key2 + MD5(key1 + “merchant=<merchant>&orderid=<orderid>&transact=<transact>))
            string md5CheckValue = string.Empty;
            md5CheckValue += settings[ "md5k1" ];
            md5CheckValue += "merchant=" + merchant;
            md5CheckValue += "&orderid=" + order.CartNumber;
            md5CheckValue += "&transact=" + order.TransactionInformation.TransactionId;

            inputFields[ "md5key" ] = GenerateMD5Hash( settings[ "md5k2" ] + GenerateMD5Hash( md5CheckValue ) );

            try {
              string response = MakePostRequest( "https://payment.architrade.com/cgi-adm/cancel.cgi", inputFields, new NetworkCredential( settings[ "apiusername" ], settings[ "apipassword" ] ) );

              Regex reg = new Regex( @"result=(\d*)" );
              string result = reg.Match( response ).Groups[ 1 ].Value;

              if ( result == "0" ) {
            apiInfo = new ApiInfo( order.TransactionInformation.TransactionId, PaymentState.Cancelled );
              } else {
            LoggingService.Instance.Log( "DIBS(" + order.OrderNumber + ") - Error making API request - error message: " + result );
              }
            } catch ( WebException ) {
              LoggingService.Instance.Log( "DIBS(" + order.OrderNumber + ") - Error making API request - wrong credentials" );
            }

              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "DIBS(" + order.OrderNumber + ") - Refund payment" );
              }

              return apiInfo;
        }
Exemplo n.º 39
0
        public override PaymentHtmlForm GenerateHtmlForm( Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary<string, string> settings )
        {
            order.MustNotBeNull( "order" );
              settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "paymentFormUrl", "settings" );

              PaymentHtmlForm htmlForm = new PaymentHtmlForm {
            Action = settings[ "paymentFormUrl" ]
              };

              order.Properties.AddOrUpdate( new CustomProperty( "teaCommerceCommunicationUrl", teaCommerceCommunicationUrl ) { ServerSideOnly = true } );
              order.Properties.AddOrUpdate( new CustomProperty( "teaCommerceContinueUrl", teaCommerceContinueUrl ) { ServerSideOnly = true } );
              order.Properties.AddOrUpdate( new CustomProperty( "teaCommerceCallbackUrl", teaCommerceCallBackUrl ) { ServerSideOnly = true } );

              return htmlForm;
        }
Exemplo n.º 40
0
        public override ApiInfo CapturePayment( Order order, IDictionary<string, string> settings )
        {
            try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "mode", "settings" );
            settings.MustContainKey( settings[ "mode" ] + "_secret_key", "settings" );

            StripeChargeService chargeService = new StripeChargeService( settings[ settings[ "mode" ] + "_secret_key" ] );
            StripeCharge charge = chargeService.Capture( order.TransactionInformation.TransactionId, (int)order.TransactionInformation.AmountAuthorized.Value * 100 );

            return new ApiInfo( charge.Id, GetPaymentState( charge ) );
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Stripe(" + order.OrderNumber + ") - GetStatus" );
              }

              return null;
        }
Exemplo n.º 41
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );

            AnnulAuthorizationRequest request = new AnnulAuthorizationRequest( order.TransactionInformation.TransactionId, order.TransactionInformation.AmountAuthorized.Value );
            GetClient( settings ).AnnulAuthorization( request );

            apiInfo = new ApiInfo( order.TransactionInformation.TransactionId, PaymentState.Cancelled );
              } catch ( Exception exp ) {
            LoggingService.Instance.Error<Paynova>( "Paynova(" + order.OrderNumber + ") - Refund payment", exp );
              }

              return apiInfo;
        }
Exemplo n.º 42
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "apiKey", "settings" );

            Dictionary<string, string> parameters = new Dictionary<string, string>();

            apiInfo = MakeApiRequest( order.TransactionInformation.TransactionId, settings[ "apiKey" ], "cancel", parameters );
              } catch ( Exception exp ) {
            LoggingService.Instance.Error<QuickPay10>( "QuickPay(" + order.OrderNumber + ") - Cancel payment", exp );
              }

              return apiInfo;
        }
Exemplo n.º 43
0
        public override PaymentHtmlForm GenerateHtmlForm( Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary<string, string> settings )
        {
            order.MustNotBeNull( "order" );
              settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "form_url", "settings" );

              PaymentHtmlForm htmlForm = new PaymentHtmlForm {
            Action = settings[ "form_url" ]
              };

              htmlForm.InputFields[ "form_url" ] = settings.ContainsKey( "mode" ) && settings[ "mode" ] == "live" ? LiveTransactionEndpoint : TestTransactionEndpoint;

              htmlForm.InputFields[ "cancel_url" ] = teaCommerceCancelUrl;
              htmlForm.InputFields[ "communication_url" ] = teaCommerceCommunicationUrl;
              order.Properties.AddOrUpdate( new CustomProperty( "teaCommerceContinueUrl", teaCommerceContinueUrl ) { ServerSideOnly = true } );
              order.Properties.AddOrUpdate( new CustomProperty( "teaCommerceCallBackUrl", teaCommerceCallBackUrl ) { ServerSideOnly = true } );
              order.Save();

              return htmlForm;
        }
Exemplo n.º 44
0
        public override PaymentHtmlForm GenerateHtmlForm( Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary<string, string> settings )
        {
            order.MustNotBeNull( "order" );
              settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "x_login", "settings" );
              settings.MustContainKey( "x_type", "settings" );
              settings.MustContainKey( "transactionKey", "settings" );

              PaymentHtmlForm htmlForm = new PaymentHtmlForm {
            Action = settings.ContainsKey( "testing" ) && settings[ "testing" ] == "1" ? "https://test.authorize.net/gateway/transact.dll" : "https://secure.authorize.net/gateway/transact.dll"
              };

              string[] settingsToExclude = new[] { "transactionKey", "md5HashKey", "testing" };
              htmlForm.InputFields = settings.Where( i => !settingsToExclude.Contains( i.Key ) ).ToDictionary( i => i.Key, i => i.Value );

              //Future: Would be cool to support item lines for this one - you have to return a List<Tuple<string, string>> for it to work with this provider
              htmlForm.InputFields[ "x_version" ] = "3.1";
              htmlForm.InputFields[ "x_show_form" ] = "PAYMENT_FORM";
              htmlForm.InputFields[ "x_relay_always" ] = "false";
              htmlForm.InputFields[ "x_relay_response" ] = "TRUE";
              htmlForm.InputFields[ "x_receipt_link_method" ] = "LINK";

              htmlForm.InputFields[ "x_invoice_num" ] = order.CartNumber;

              string amount = order.TotalPrice.Value.WithVat.ToString( "0.00", CultureInfo.InvariantCulture );
              htmlForm.InputFields[ "x_amount" ] = amount;

              htmlForm.InputFields[ "x_receipt_link_url" ] = teaCommerceContinueUrl;
              htmlForm.InputFields[ "x_cancel_url" ] = teaCommerceCancelUrl;

              string sequenceNumber = new Random().Next( 0, 1000 ).ToString( CultureInfo.InvariantCulture );
              htmlForm.InputFields[ "x_fp_sequence" ] = sequenceNumber;

              string timestamp = ( DateTime.UtcNow - new DateTime( 1970, 1, 1 ) ).TotalSeconds.ToString( "0", CultureInfo.InvariantCulture );
              htmlForm.InputFields[ "x_fp_timestamp" ] = timestamp;
              htmlForm.InputFields[ "x_fp_hash" ] = new HMACMD5( Encoding.UTF8.GetBytes( settings[ "transactionKey" ] ) ).ComputeHash( Encoding.UTF8.GetBytes( settings[ "x_login" ] + "^" + sequenceNumber + "^" + timestamp + "^" + amount + "^" ) ).ToHex();

              return htmlForm;
        }
Exemplo n.º 45
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "merchantnumber", "settings" );

            int ePayResponse = 0;

            if ( GetEPayServiceClient().delete( int.Parse( settings[ "merchantnumber" ] ), long.Parse( order.TransactionInformation.TransactionId ), string.Empty, settings.ContainsKey( "webservicepassword" ) ? settings[ "webservicepassword" ] : string.Empty, ref ePayResponse ) ) {
              apiInfo = new ApiInfo( order.TransactionInformation.TransactionId, PaymentState.Cancelled );
            } else {
              LoggingService.Instance.Warn<ePay>( "ePay(" + order.OrderNumber + ") - Error making API request - error code: " + ePayResponse );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Error<ePay>( "ePay(" + order.OrderNumber + ") - Cancel payment", exp );
              }

              return apiInfo;
        }
Exemplo n.º 46
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "SECURITY.SENDER", "settings" );
            settings.MustContainKey( "USER.LOGIN", "settings" );
            settings.MustContainKey( "USER.PWD", "settings" );
            settings.MustContainKey( "TRANSACTION.CHANNEL", "settings" );
            settings.MustContainKey( "TRANSACTION.MODE", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();
            inputFields[ "REQUEST.VERSION" ] = "1.0";

            inputFields[ "SECURITY.SENDER" ] = settings[ "SECURITY.SENDER" ];
            inputFields[ "USER.LOGIN" ] = settings[ "USER.LOGIN" ];
            inputFields[ "USER.PWD" ] = settings[ "USER.PWD" ];
            inputFields[ "TRANSACTION.CHANNEL" ] = settings[ "TRANSACTION.CHANNEL" ];

            inputFields[ "PAYMENT.CODE" ] = "CC.RV";
            inputFields[ "IDENTIFICATION.REFERENCEID" ] = order.TransactionInformation.TransactionId;
            inputFields[ "TRANSACTION.MODE" ] = settings[ "TRANSACTION.MODE" ];

            IDictionary<string, string> responseKvps = MakePostRequest( settings, inputFields );
            if ( responseKvps[ "PROCESSING.RESULT" ] == "ACK" ) {
              apiInfo = new ApiInfo( responseKvps[ "IDENTIFICATION.UNIQUEID" ], PaymentState.Cancelled );
            } else {
              LoggingService.Instance.Log( "Axcess(" + order.OrderNumber + ") - Error making API request - PROCESSING.CODE: " + responseKvps[ "PROCESSING.CODE" ] );
            }

              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Axcess(" + order.OrderNumber + ") - Cancel payment" );
              }

              return apiInfo;
        }
Exemplo n.º 47
0
        public override ApiInfo CancelPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "merchantId", "settings" );
            settings.MustContainKey( "token", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();
            inputFields[ "merchantId" ] = settings[ "merchantId" ];
            inputFields[ "token" ] = settings[ "token" ];
            inputFields[ "operation" ] = "ANNUL";
            inputFields[ "transactionId" ] = order.TransactionInformation.TransactionId;

            apiInfo = MakeApiRequest( order.OrderNumber, inputFields, order.TransactionInformation.TransactionId, PaymentState.Cancelled, settings.ContainsKey( "testMode" ) && settings[ "testMode" ] == "1" ? "https://epayment-test.bbs.no/Netaxept/Process.aspx" : "https://epayment.bbs.no/Netaxept/Process.aspx" );
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Netaxept(" + order.OrderNumber + ") - Cancel payment" );
              }

              return apiInfo;
        }
Exemplo n.º 48
0
        public override PaymentHtmlForm GenerateHtmlForm( Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary<string, string> settings )
        {
            order.MustNotBeNull( "order" );
              settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "form_url", "settings" );
              settings.MustContainKey( "mode", "settings" );
              settings.MustContainKey( settings[ "mode" ] + "_public_key", "settings" );

              PaymentHtmlForm htmlForm = new PaymentHtmlForm {
            Action = settings[ "form_url" ]
              };

              string[] settingsToExclude = new[] { "form_url", "capture", "test_secret_key", "test_public_key", "live_secret_key", "live_public_key", "mode" };
              htmlForm.InputFields = settings.Where( i => !settingsToExclude.Contains( i.Key ) ).ToDictionary( i => i.Key, i => i.Value );

              htmlForm.InputFields[ "api_key" ] = settings[ settings[ "mode" ] + "_public_key" ];
              htmlForm.InputFields[ "continue_url" ] = teaCommerceContinueUrl;
              htmlForm.InputFields[ "cancel_url" ] = teaCommerceCancelUrl;

              return htmlForm;
        }
Exemplo n.º 49
0
        public override string ProcessRequest( Order order, HttpRequest request, IDictionary<string, string> settings )
        {
            string response = "";

              try {
            order.MustNotBeNull( "order" );
            request.MustNotBeNull( "request" );
            settings.MustNotBeNull( "settings" );

            // If in test mode, write out the form data to a text file
            if ( settings.ContainsKey( "mode" ) && settings[ "mode" ] == "test" ) {
              LogRequest( request, logPostData: true );
            }

            //Stripe supports webhooks
            StripeEvent stripeEvent = GetStripeEvent( request );
            StripeCharge charge = Mapper<StripeCharge>.MapFromJson( stripeEvent.Data.Object.ToString() );

            if ( stripeEvent.Type.StartsWith( "charge." ) ) {
              PaymentState paymentState = GetPaymentState( charge );
              if ( order.TransactionInformation.PaymentState != paymentState ) {
            order.TransactionInformation.TransactionId = charge.Id;
            order.TransactionInformation.PaymentState = paymentState;
            order.Save();
              }
            }

              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Stripe(" + order.CartNumber + ") - ProcessRequest" );
              }

              return response;
        }
Exemplo n.º 50
0
        public override string GetCartNumber( HttpRequest request, IDictionary<string, string> settings )
        {
            string cartNumber = "";

              try {
            request.MustNotBeNull( "request" );
            settings.MustNotBeNull( "settings" );

            // If in test mode, write out the form data to a text file
            if ( settings.ContainsKey( "mode" ) && settings[ "mode" ] == "test" ) {
              LogRequest( request, logPostData: true );
            }

            StripeEvent stripeEvent = GetStripeEvent( request );

            // We are only interested in charge events
            if ( stripeEvent != null && stripeEvent.Type.StartsWith( "charge." ) ) {
              StripeCharge stripeCharge = Mapper<StripeCharge>.MapFromJson( stripeEvent.Data.Object.ToString() );
              cartNumber = stripeCharge.Description;
            } else {
              HttpContext.Current.Response.StatusCode = (int)HttpStatusCode.BadRequest;
            }

              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Stripe - Get cart number" );
              }

              return cartNumber;
        }
Exemplo n.º 51
0
        public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
        {
            CallbackInfo callbackInfo = null;

              try {
            order.MustNotBeNull( "order" );
            request.MustNotBeNull( "request" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "mode", "settings" );
            settings.MustContainKey( settings[ "mode" ] + "_secret_key", "settings" );

            // If in test mode, write out the form data to a text file
            if ( settings.ContainsKey( "mode" ) && settings[ "mode" ] == "test" ) {
              LogRequest( request, logPostData: true );
            }

            StripeChargeCreateOptions chargeOptions = new StripeChargeCreateOptions {
              AmountInCents = (int)( order.TotalPrice.Value.WithVat * 100 ),
              Currency = CurrencyService.Instance.Get( order.StoreId, order.CurrencyId ).IsoCode,
              TokenId = request.Form[ "stripeToken" ],
              Description = order.CartNumber,
              Capture = settings.ContainsKey( "capture" ) && ( settings[ "capture" ].TryParse<bool>() ?? false )
            };

            StripeChargeService chargeService = new StripeChargeService( settings[ settings[ "mode" ] + "_secret_key" ] );
            StripeCharge charge = chargeService.Create( chargeOptions );

            if ( charge.AmountInCents != null && charge.Paid != null && charge.Paid.Value ) {
              callbackInfo = new CallbackInfo( (decimal)charge.AmountInCents.Value / 100, charge.Id, charge.Captured != null && charge.Captured.Value ? PaymentState.Captured : PaymentState.Authorized );

            }

              } catch ( StripeException e ) {
            // Pass through request fields
            string requestFields = string.Join( "", request.Form.AllKeys.Select( k => "<input type=\"hidden\" name=\"" + k + "\" value=\"" + request.Form[ k ] + "\" />" ) );

            //Add error details from the exception.
            requestFields = requestFields + "<input type=\"hidden\" name=\"TransactionFailed\" value=\"true\" />";
            requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.chargeId\" value=\"" + e.StripeError.ChargeId + "\" />";
            requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Code\" value=\"" + e.StripeError.Code + "\" />";
            requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Error\" value=\"" + e.StripeError.Error + "\" />";
            requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.ErrorSubscription\" value=\"" + e.StripeError.ErrorSubscription + "\" />";
            requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.ErrorType\" value=\"" + e.StripeError.ErrorType + "\" />";
            requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Message\" value=\"" + e.StripeError.Message + "\" />";
            requestFields = requestFields + "<input type=\"hidden\" name=\"FailureReason.Parameter\" value=\"" + e.StripeError.Parameter + "\" />";

            string paymentForm = PaymentMethodService.Instance.Get( order.StoreId, order.PaymentInformation.PaymentMethodId.Value ).GeneratePaymentForm( order, requestFields );

            //Force the form to auto submit
            paymentForm += "<script type=\"text/javascript\">document.forms[0].submit();</script>";

            //Write out the form
            HttpContext.Current.Response.Clear();
            HttpContext.Current.Response.Write( paymentForm );
            HttpContext.Current.Response.End();
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Stripe(" + order.CartNumber + ") - ProcessCallback" );
              }

              return callbackInfo;
        }
Exemplo n.º 52
0
        public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
        {
            CallbackInfo callbackInfo = null;

              try {
            order.MustNotBeNull( "order" );
            request.MustNotBeNull( "request" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "SHAOUTPASSPHRASE", "settings" );

            //Write data when testing
            if ( settings.ContainsKey( "TESTMODE" ) && settings[ "TESTMODE" ] == "1" ) {
              LogRequest<Ogone>( request, logGetData: true );
            }

            Dictionary<string, string> inputFields = new Dictionary<string, string>();

            string shaSign = request.QueryString[ "SHASIGN" ];
            string strAmount = request.QueryString[ "AMOUNT" ];
            string transaction = request.QueryString[ "PAYID" ];
            string status = request.QueryString[ "STATUS" ];
            string cardType = request.QueryString[ "BRAND" ];
            string cardNo = request.QueryString[ "CARDNO" ];

            foreach ( string key in request.QueryString.Keys ) {
              if ( !key.Equals( "SHASIGN" ) )
            inputFields[ key ] = request.QueryString[ key ];
            }

            string strToHash = string.Join( "", inputFields.OrderBy( i => i.Key ).Select( i => i.Key.ToUpperInvariant() + "=" + i.Value + settings[ "SHAOUTPASSPHRASE" ] ) );
            string digest = new SHA512Managed().ComputeHash( Encoding.UTF8.GetBytes( strToHash ) ).ToHex().ToUpperInvariant();

            if ( order.CartNumber == request.QueryString[ "ORDERID" ] && digest.Equals( shaSign ) ) {
              callbackInfo = new CallbackInfo( decimal.Parse( strAmount, CultureInfo.InvariantCulture ), transaction, status == "5" || status == "51" ? PaymentState.Authorized : PaymentState.Captured, cardType, cardNo );
            } else {
              LoggingService.Instance.Warn<Ogone>( "Ogone(" + order.CartNumber + ") - SHASIGN check isn't valid - Calculated digest: " + digest + " - Ogone SHASIGN: " + shaSign );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Error<Ogone>( "Ogone(" + order.CartNumber + ") - Process callback", exp );
              }

              return callbackInfo;
        }
Exemplo n.º 53
0
        protected XDocument MakeApiRequest( string methodName, string operation, Order order, IDictionary<string, string> settings )
        {
            order.MustNotBeNull( "order" );
              settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "PSPID", "settings" );
              settings.MustContainKey( "APIUSERID", "settings" );
              settings.MustContainKey( "APIPASSWORD", "settings" );
              settings.MustContainKey( "SHAINPASSPHRASE", "settings" );

              Dictionary<string, string> inputFields = new Dictionary<string, string>();

              inputFields[ "PSPID" ] = settings[ "PSPID" ];
              inputFields[ "USERID" ] = settings[ "APIUSERID" ];
              inputFields[ "PSWD" ] = settings[ "APIPASSWORD" ];
              inputFields[ "PAYID" ] = order.TransactionInformation.TransactionId;
              if ( !methodName.Equals( "STATUS" ) ) {
            inputFields[ "AMOUNT" ] = ( order.TransactionInformation.AmountAuthorized.Value * 100M ).ToString( "0", CultureInfo.InvariantCulture );
            inputFields[ "OPERATION" ] = operation;
              }

              string strToHash = string.Join( "", inputFields.OrderBy( i => i.Key ).Select( i => i.Key.ToUpperInvariant() + "=" + i.Value + settings[ "SHAINPASSPHRASE" ] ) );
              inputFields[ "SHASIGN" ] = new SHA512Managed().ComputeHash( Encoding.UTF8.GetBytes( strToHash ) ).ToHex();

              string response = MakePostRequest( GetMethodUrl( methodName, settings ), inputFields );
              return XDocument.Parse( response, LoadOptions.PreserveWhitespace );
        }
Exemplo n.º 54
0
        public override ApiInfo CapturePayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "Vendor", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();

            Guid vendorTxCode = Guid.NewGuid();

            inputFields[ "VPSProtocol" ] = "2.23";
            inputFields[ "TxType" ] = "AUTHORISE";
            inputFields[ "Vendor" ] = settings[ "Vendor" ];
            inputFields[ "VendorTxCode" ] = vendorTxCode.ToString();
            inputFields[ "Amount" ] = order.TransactionInformation.AmountAuthorized.Value.ToString( "0.00", CultureInfo.InvariantCulture );
            inputFields[ "Description" ] = settings[ "Description" ].Truncate( 100 );
            inputFields[ "RelatedVPSTxId" ] = order.TransactionInformation.TransactionId;
            inputFields[ "RelatedVendorTxCode" ] = order.CartNumber;
            inputFields[ "RelatedSecurityKey" ] = order.Properties[ "securityKey" ];
            inputFields[ "ApplyAVSCV2" ] = "0";

            IDictionary<string, string> responseFields = GetFields( MakePostRequest( GetMethodUrl( "AUTHORISE", settings ), inputFields ) );

            if ( responseFields[ "Status" ] == "OK" ) {
              order.Properties.AddOrUpdate( new CustomProperty( "vendorTxCode", vendorTxCode.ToString() ) { ServerSideOnly = true } );
              order.Properties.AddOrUpdate( new CustomProperty( "txAuthNo", responseFields[ "TxAuthNo" ] ) { ServerSideOnly = true } );
              order.Properties.AddOrUpdate( new CustomProperty( "securityKey", responseFields[ "SecurityKey" ] ) { ServerSideOnly = true } );
              order.Save();

              apiInfo = new ApiInfo( responseFields[ "VPSTxId" ], PaymentState.Captured );
            } else {
              LoggingService.Instance.Log( "Sage pay(" + order.OrderNumber + ") - Error making API request: " + responseFields[ "StatusDetail" ] );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Sage pay(" + order.OrderNumber + ") - Cancel payment" );
              }

              return apiInfo;
        }
Exemplo n.º 55
0
        public override PaymentHtmlForm GenerateHtmlForm( Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary<string, string> settings )
        {
            order.MustNotBeNull( "order" );
              settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "SHAINPASSPHRASE", "settings" );

              PaymentHtmlForm htmlForm = new PaymentHtmlForm {
            Action = GetMethodUrl( "GENERATEFORM", settings )
              };

              string[] settingsToExclude = new[] { "SHAINPASSPHRASE", "SHAOUTPASSPHRASE", "APIUSERID", "APIPASSWORD", "TESTMODE" };
              htmlForm.InputFields = settings.Where( i => !settingsToExclude.Contains( i.Key ) && !string.IsNullOrEmpty( i.Value ) ).ToDictionary( i => i.Key.ToUpperInvariant(), i => i.Value );

              htmlForm.InputFields[ "ORDERID" ] = order.CartNumber;
              htmlForm.InputFields[ "AMOUNT" ] = ( order.TotalPrice.Value.WithVat * 100M ).ToString( "0", CultureInfo.InvariantCulture );

              //Check that the Iso code exists
              Currency currency = CurrencyService.Instance.Get( order.StoreId, order.CurrencyId );
              if ( !Iso4217CurrencyCodes.ContainsKey( currency.IsoCode ) ) {
            throw new Exception( "You must specify an ISO 4217 currency code for the " + currency.Name + " currency" );
              }
              htmlForm.InputFields[ "CURRENCY" ] = currency.IsoCode;

              htmlForm.InputFields[ "CN" ] = order.PaymentInformation.FirstName + " " + order.PaymentInformation.LastName;
              htmlForm.InputFields[ "EMAIL" ] = order.PaymentInformation.Email;
              htmlForm.InputFields[ "ACCEPTURL" ] = teaCommerceContinueUrl;
              htmlForm.InputFields[ "DECLINEURL" ] = teaCommerceCancelUrl;
              htmlForm.InputFields[ "EXCEPTIONURL" ] = teaCommerceCancelUrl;
              htmlForm.InputFields[ "CANCELURL" ] = teaCommerceCancelUrl;

              //Ogone dont support to show order line information to the shopper

              string strToHash = string.Join( "", htmlForm.InputFields.OrderBy( i => i.Key ).Select( i => i.Key + "=" + i.Value + settings[ "SHAINPASSPHRASE" ] ) );
              htmlForm.InputFields[ "SHASIGN" ] = new SHA512Managed().ComputeHash( Encoding.UTF8.GetBytes( strToHash ) ).ToHex();

              return htmlForm;
        }
Exemplo n.º 56
0
        public override string GetCartNumber( HttpRequest request, IDictionary<string, string> settings )
        {
            string cartNumber = "";

              try {
            request.MustNotBeNull( "request" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "md5HashKey", "settings" );
            settings.MustContainKey( "x_login", "settings" );

            //Write data when testing
            if ( settings.ContainsKey( "testing" ) && settings[ "testing" ] == "1" ) {
              LogRequest( request, logPostData: true );
            }

            string responseCode = request.Form[ "x_response_code" ];
            if ( responseCode == "1" ) {

              string amount = request.Form[ "x_amount" ];
              string transaction = request.Form[ "x_trans_id" ];

              string gatewayMd5Hash = request.Form[ "x_MD5_Hash" ];

              MD5CryptoServiceProvider x = new MD5CryptoServiceProvider();
              string calculatedMd5Hash = Regex.Replace( BitConverter.ToString( x.ComputeHash( Encoding.ASCII.GetBytes( settings[ "md5HashKey" ] + settings[ "x_login" ] + transaction + amount ) ) ), "-", string.Empty );

              if ( gatewayMd5Hash == calculatedMd5Hash ) {
            cartNumber = request.Form[ "x_invoice_num" ];
              } else {
            LoggingService.Instance.Log( "Authorize.net - MD5Sum security check failed - " + gatewayMd5Hash + " - " + calculatedMd5Hash + " - " + settings[ "md5HashKey" ] );
              }
            } else {
              LoggingService.Instance.Log( "Authorize.net - Payment not approved: " + responseCode );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Authorize.net - Get cart number" );
              }

              return cartNumber;
        }
Exemplo n.º 57
0
        protected string GetMethodUrl( string type, IDictionary<string, string> settings )
        {
            settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "testMode", "settings" );

              switch ( settings[ "testMode" ].ToUpperInvariant() ) {
            case "LIVE":
              switch ( type.ToUpperInvariant() ) {
            case "AUTHORISE":
              return "https://live.sagepay.com/gateway/service/authorise.vsp";
            case "PURCHASE":
              return "https://live.sagepay.com/gateway/service/vspserver-register.vsp";
            case "CANCEL":
              return "https://live.sagepay.com/gateway/service/cancel.vsp";
            case "REFUND":
              return "https://live.sagepay.com/gateway/service/refund.vsp";
              }
              break;
            case "TEST":
              switch ( type.ToUpperInvariant() ) {
            case "AUTHORISE":
              return "https://test.sagepay.com/gateway/service/authorise.vsp";
            case "PURCHASE":
              return "https://test.sagepay.com/gateway/service/vspserver-register.vsp";
            case "CANCEL":
              return "https://test.sagepay.com/gateway/service/cancel.vsp";
            case "REFUND":
              return "https://test.sagepay.com/gateway/service/refund.vsp";
              }
              break;
            case "SIMULATOR":
              switch ( type.ToUpperInvariant() ) {
            case "AUTHORISE":
              return "https://test.sagepay.com/simulator/vspserverGateway.asp?Service=VendorAuthoriseTx";
            case "PURCHASE":
              return "https://test.sagepay.com/simulator/VSPServerGateway.asp?Service=VendorRegisterTx";
            case "CANCEL":
              return "https://test.sagepay.com/simulator/vspserverGateway.asp?Service=VendorCancelTx";
            case "REFUND":
              return "https://test.sagepay.com/simulator/vspserverGateway.asp?Service=VendorRefundTx";
              }
              break;
              }

              return string.Empty;
        }
Exemplo n.º 58
0
        public override ApiInfo RefundPayment( Order order, IDictionary<string, string> settings )
        {
            ApiInfo apiInfo = null;

              try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "Vendor", "settings" );
            settings.MustContainKey( "Description", "settings" );

            Dictionary<string, string> inputFields = new Dictionary<string, string>();

            Guid vendorTxCode = Guid.NewGuid();

            inputFields[ "VPSProtocol" ] = "2.23";
            inputFields[ "TxType" ] = "REFUND";
            inputFields[ "Vendor" ] = settings[ "Vendor" ];
            inputFields[ "VendorTxCode" ] = vendorTxCode.ToString();
            inputFields[ "Amount" ] = order.TransactionInformation.AmountAuthorized.Value.ToString( "0.00", CultureInfo.InvariantCulture );
            //Check that the Iso code exists
            Currency currency = CurrencyService.Instance.Get( order.StoreId, order.CurrencyId );
            if ( !Iso4217CurrencyCodes.ContainsKey( currency.IsoCode ) ) {
              throw new Exception( "You must specify an ISO 4217 currency code for the " + currency.Name + " currency" );
            }
            inputFields[ "Currency" ] = currency.IsoCode;
            inputFields[ "Description" ] = settings[ "Description" ].Truncate( 100 );
            inputFields[ "RelatedVPSTxId" ] = order.TransactionInformation.TransactionId;
            inputFields[ "RelatedVendorTxCode" ] = order.Properties[ "vendorTxCode" ];
            inputFields[ "RelatedSecurityKey" ] = order.Properties[ "securityKey" ];
            inputFields[ "RelatedTxAuthNo" ] = order.Properties[ "txAuthNo" ];
            inputFields[ "ApplyAVSCV2" ] = "0";

            IDictionary<string, string> responseFields = GetFields( MakePostRequest( GetMethodUrl( "REFUND", settings ), inputFields ) );

            if ( responseFields[ "Status" ] == "OK" ) {
              order.Properties.AddOrUpdate( new CustomProperty( "vendorTxCode", vendorTxCode.ToString() ) { ServerSideOnly = true } );
              order.Properties.AddOrUpdate( new CustomProperty( "txAuthNo", responseFields[ "TxAuthNo" ] ) { ServerSideOnly = true } );
              order.Save();

              apiInfo = new ApiInfo( responseFields[ "VPSTxId" ], PaymentState.Refunded );
            } else {
              LoggingService.Instance.Log( "Sage pay(" + order.OrderNumber + ") - Error making API request: " + responseFields[ "StatusDetail" ] );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Sage pay(" + order.OrderNumber + ") - Refund payment" );
              }

              return apiInfo;
        }
Exemplo n.º 59
0
        public override CallbackInfo ProcessCallback( Order order, HttpRequest request, IDictionary<string, string> settings )
        {
            CallbackInfo callbackInfo = null;

              try {
            order.MustNotBeNull( "order" );
            request.MustNotBeNull( "request" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "Vendor", "settings" );

            //Write data when testing
            if ( settings.ContainsKey( "testMode" ) && ( settings[ "testMode" ] == "SIMULATOR" || settings[ "testMode" ] == "TEST" ) ) {
              LogRequest( request, logPostData: true );
            }

            string transaction = request.Form[ "VPSTxId" ];
            string status = request.Form[ "Status" ];
            string cartNumber = request.Form[ "VendorTxCode" ];
            string txAuthNo = request.Form[ "TxAuthNo" ];
            string cardType = request.Form[ "CardType" ];
            string last4Digits = request.Form[ "Last4Digits" ];

            string md5CheckValue = string.Empty;
            md5CheckValue += transaction;
            md5CheckValue += cartNumber;
            md5CheckValue += status;
            md5CheckValue += txAuthNo;
            md5CheckValue += settings[ "Vendor" ].ToLowerInvariant();
            md5CheckValue += HttpUtility.UrlDecode( request.Form[ "AVSCV2" ] );
            md5CheckValue += order.Properties[ "securityKey" ];
            md5CheckValue += HttpUtility.UrlDecode( request.Form[ "AddressResult" ] );
            md5CheckValue += HttpUtility.UrlDecode( request.Form[ "PostCodeResult" ] );
            md5CheckValue += HttpUtility.UrlDecode( request.Form[ "CV2Result" ] );
            md5CheckValue += request.Form[ "GiftAid" ];
            md5CheckValue += request.Form[ "3DSecureStatus" ];
            md5CheckValue += request.Form[ "CAVV" ];
            md5CheckValue += HttpUtility.UrlDecode( request.Form[ "AddressStatus" ] );
            md5CheckValue += HttpUtility.UrlDecode( request.Form[ "PayerStatus" ] );
            md5CheckValue += cardType;
            md5CheckValue += last4Digits;

            string calcedMd5Hash = GenerateMD5Hash( md5CheckValue ).ToUpperInvariant();
            string vpsSignature = request.Form[ "VPSSignature" ];

            if ( order.CartNumber == cartNumber && calcedMd5Hash == vpsSignature ) {

              Dictionary<string, string> inputFields = new Dictionary<string, string>();

              if ( status == "OK" || status == "AUTHENTICATED" || status == "REGISTERED" ) {
            callbackInfo = new CallbackInfo( order.TotalPrice.Value.WithVat, transaction, request.Form[ "TxType" ] != "PAYMENT" ? PaymentState.Authorized : PaymentState.Captured, cardType, last4Digits );

            if ( status == "OK" ) {
              order.Properties.AddOrUpdate( new CustomProperty( "txAuthNo", txAuthNo ) { ServerSideOnly = true } );
            }
            order.Properties.AddOrUpdate( new CustomProperty( "vendorTxCode", cartNumber ) { ServerSideOnly = true } );
            order.Save();

            inputFields[ "Status" ] = "OK";
            inputFields[ "RedirectURL" ] = order.Properties[ "teaCommerceContinueUrl" ];
            inputFields[ "StatusDetail" ] = "OK";

              } else {
            LoggingService.Instance.Log( "Sage Pay(" + order.CartNumber + ") - Error  in callback - status: " + status + " | status details: " + request.Form[ "StatusDetail" ] );

            if ( status == "ERROR" )
              inputFields[ "Status" ] = "INVALID";
            else
              inputFields[ "Status" ] = "OK";

            inputFields[ "RedirectURL" ] = order.Properties[ "teaCommerceCancelUrl" ];
            inputFields[ "StatusDetail" ] = "Error: " + status;
              }

              HttpContext.Current.Response.Clear();
              HttpContext.Current.Response.Write( string.Join( Environment.NewLine, inputFields.Select( i => string.Format( "{0}={1}", i.Key, i.Value ) ).ToArray() ) );
            } else {
              LoggingService.Instance.Log( "Sage Pay(" + order.CartNumber + ") - VPSSignature check isn't valid - Calculated signature: " + calcedMd5Hash + " | SagePay VPSSignature: " + vpsSignature );
            }
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Sage Pay(" + order.CartNumber + ") - Process callback" );
              }

              return callbackInfo;
        }
Exemplo n.º 60
0
        public override PaymentHtmlForm GenerateHtmlForm( Order order, string teaCommerceContinueUrl, string teaCommerceCancelUrl, string teaCommerceCallBackUrl, string teaCommerceCommunicationUrl, IDictionary<string, string> settings )
        {
            order.MustNotBeNull( "order" );
              settings.MustNotBeNull( "settings" );
              settings.MustContainKey( "streetAddressPropertyAlias", "settings" );
              settings.MustContainKey( "cityPropertyAlias", "settings" );
              settings.MustContainKey( "zipCodePropertyAlias", "settings" );
              settings.MustContainKey( "Description", "settings" );

              PaymentHtmlForm htmlForm = new PaymentHtmlForm();

              string[] settingsToExclude = new[] { "streetAddressPropertyAlias", "cityPropertyAlias", "zipCodePropertyAlias", "phonePropertyAlias", "shipping_firstNamePropertyAlias", "shipping_lastNamePropertyAlias", "shipping_streetAddressPropertyAlias", "shipping_cityPropertyAlias", "shipping_zipCodePropertyAlias", "shipping_phonePropertyAlias", "testMode" };
              Dictionary<string, string> inputFields = settings.Where( i => !settingsToExclude.Contains( i.Key ) ).ToDictionary( i => i.Key, i => i.Value );

              inputFields[ "VPSProtocol" ] = "2.23";

              #region Address properties

              string streetAddress = order.Properties[ settings[ "streetAddressPropertyAlias" ] ];
              string city = order.Properties[ settings[ "cityPropertyAlias" ] ];
              string zipCode = order.Properties[ settings[ "zipCodePropertyAlias" ] ];

              streetAddress.MustNotBeNullOrEmpty( "streetAddress" );
              city.MustNotBeNullOrEmpty( "city" );
              zipCode.MustNotBeNullOrEmpty( "zipCode" );

              string shippingFirstName = settings.ContainsKey( "shipping_firstNamePropertyAlias" ) ? order.Properties[ settings[ "shipping_firstNamePropertyAlias" ] ] : "";
              if ( string.IsNullOrEmpty( shippingFirstName ) ) {
            shippingFirstName = order.PaymentInformation.FirstName;
              }

              string shippingLastName = settings.ContainsKey( "shipping_lastNamePropertyAlias" ) ? order.Properties[ settings[ "shipping_lastNamePropertyAlias" ] ] : "";
              if ( string.IsNullOrEmpty( shippingLastName ) ) {
            shippingLastName = order.PaymentInformation.LastName;
              }

              string shippingStreetAddress = settings.ContainsKey( "shipping_streetAddressPropertyAlias" ) ? order.Properties[ settings[ "shipping_streetAddressPropertyAlias" ] ] : "";
              if ( string.IsNullOrEmpty( shippingStreetAddress ) ) {
            shippingStreetAddress = streetAddress;
              }

              string shippingCity = settings.ContainsKey( "shipping_cityPropertyAlias" ) ? order.Properties[ settings[ "shipping_cityPropertyAlias" ] ] : "";
              if ( string.IsNullOrEmpty( shippingCity ) ) {
            shippingCity = city;
              }

              string shippingZipCode = settings.ContainsKey( "shipping_zipCodePropertyAlias" ) ? order.Properties[ settings[ "shipping_zipCodePropertyAlias" ] ] : "";
              if ( string.IsNullOrEmpty( shippingZipCode ) ) {
            shippingZipCode = zipCode;
              }

              #endregion

              if ( order.CartNumber.Length > 40 ) {
            throw new Exception( "Cart number of the order can not exceed 40 characters." );
              }
              inputFields[ "VendorTxCode" ] = order.CartNumber;
              inputFields[ "Amount" ] = order.TotalPrice.Value.WithVat.ToString( "0.00", CultureInfo.InvariantCulture );

              //Check that the Iso code exists
              Currency currency = CurrencyService.Instance.Get( order.StoreId, order.CurrencyId );
              if ( !Iso4217CurrencyCodes.ContainsKey( currency.IsoCode ) ) {
            throw new Exception( "You must specify an ISO 4217 currency code for the " + currency.Name + " currency" );
              }
              inputFields[ "Currency" ] = currency.IsoCode;
              inputFields[ "Description" ] = inputFields[ "Description" ].Truncate( 100 );
              inputFields[ "SuccessURL" ] = teaCommerceContinueUrl;
              inputFields[ "FailureURL" ] = teaCommerceCancelUrl;
              inputFields[ "NotificationURL" ] = teaCommerceCallBackUrl;
              inputFields[ "BillingSurname" ] = order.PaymentInformation.LastName.Truncate( 20 );
              inputFields[ "BillingFirstnames" ] = order.PaymentInformation.FirstName.Truncate( 20 );
              inputFields[ "BillingAddress1" ] = streetAddress.Truncate( 100 );
              inputFields[ "BillingCity" ] = city.Truncate( 40 );
              inputFields[ "BillingPostCode" ] = zipCode.Truncate( 10 );

              Country country = CountryService.Instance.Get( order.StoreId, order.PaymentInformation.CountryId );
              inputFields[ "BillingCountry" ] = country.RegionCode;
              if ( country.RegionCode.ToUpperInvariant() == "US" && order.PaymentInformation.CountryRegionId != null ) {
            CountryRegion countryRegion = CountryRegionService.Instance.Get( order.StoreId, order.PaymentInformation.CountryRegionId.Value );
            inputFields[ "BillingState" ] = countryRegion.RegionCode.Truncate( 2 );
              }
              if ( settings.ContainsKey( "phonePropertyAlias" ) ) {
            inputFields[ "BillingPhone" ] = order.Properties[ settings[ "phonePropertyAlias" ] ].Truncate( 20 );
              }

              inputFields[ "DeliverySurname" ] = shippingLastName.Truncate( 20 );
              inputFields[ "DeliveryFirstnames" ] = shippingFirstName.Truncate( 20 );
              inputFields[ "DeliveryAddress1" ] = shippingStreetAddress.Truncate( 100 );
              inputFields[ "DeliveryCity" ] = shippingCity.Truncate( 40 );
              inputFields[ "DeliveryPostCode" ] = shippingZipCode.Truncate( 10 );

              country = CountryService.Instance.Get( order.StoreId, order.ShipmentInformation.CountryId ?? order.PaymentInformation.CountryId );
              inputFields[ "DeliveryCountry" ] = country.RegionCode;

              long? shippingCountryRegionId = order.ShipmentInformation.CountryId != null ? order.ShipmentInformation.CountryRegionId : order.PaymentInformation.CountryRegionId;
              if ( country.RegionCode.ToUpperInvariant() == "US" && shippingCountryRegionId != null ) {
            CountryRegion countryRegion = CountryRegionService.Instance.Get( order.StoreId, shippingCountryRegionId.Value );
            inputFields[ "DeliveryState" ] = countryRegion.RegionCode.Truncate( 2 );
              }
              if ( settings.ContainsKey( "shipping_phonePropertyAlias" ) ) {
            inputFields[ "DeliveryPhone" ] = order.Properties[ settings[ "shipping_phonePropertyAlias" ] ].Truncate( 20 );
              }

              inputFields[ "Apply3DSecure" ] = "2";

              IDictionary<string, string> responseFields = GetFields( MakePostRequest( GetMethodUrl( "PURCHASE", settings ), inputFields ) );
              string status = responseFields[ "Status" ];

              if ( status == "OK" || status == "OK REPEATED" ) {
            order.Properties.AddOrUpdate( new CustomProperty( "securityKey", responseFields[ "SecurityKey" ] ) { ServerSideOnly = true } );
            order.Properties.AddOrUpdate( new CustomProperty( "teaCommerceContinueUrl", teaCommerceContinueUrl ) { ServerSideOnly = true } );
            order.Properties.AddOrUpdate( new CustomProperty( "teaCommerceCancelUrl", teaCommerceCancelUrl ) { ServerSideOnly = true } );
            order.Save();
            htmlForm.Action = responseFields[ "NextURL" ];
              } else {
            htmlForm.Action = teaCommerceCancelUrl;
            LoggingService.Instance.Log( "Sage Pay(" + order.CartNumber + ") - Generate html form error - status: " + status + " | status details: " + responseFields[ "StatusDetail" ] );
              }

              return htmlForm;
        }