C# Order.MustNotBeNull方法代码示例

        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 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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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;
        }

        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 );
        }

        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;
        }