Merge pull request #94 from CyberSource/march-changes

March changes

Author: gnongsie

CyberSource/__init__.py

@@ -164,7 +164,10 @@ def set_configuration(self,config):
         # This implements the fall back logic for JWT parameters key alias,key password,json file path
         self.mconfig.validate_merchant_details(config)
         # Setting the Host by reading the Environment(SANDBOX/PRODUCTION) from Merchant Config
-        self.host = self.mconfig.request_host
+        if self.mconfig.IntermediateHost:
+            self.host = self.mconfig.IntermediateHost
+        else:
+            self.host = self.mconfig.request_host
 
     # Calling the authentication header
     def call_authentication_header(self, method, header_params, body):
@@ -283,12 +286,30 @@ def __call_api(self, resource_path, method,
             body = self.sanitize_for_serialization(body)
 
         # request url
-        url = GlobalLabelParameters.HTTP_URL_PREFIX+self.host + resource_path
+        if self.host.startswith("https://") or self.host.startswith("http://"):
+            url = self.host + resource_path
+        else:
+            url = GlobalLabelParameters.HTTP_URL_PREFIX+self.host + resource_path
 
         if self.download_file_path is not None:
             _preload_content = False        
             _request_timeout = 3000
 
+        # add client additional headers and override the previous one except signature header
+        if(self.mconfig.default_headers):
+            signVal=None
+            authVal=None
+            if "Signature" in header_params:
+                signVal= header_params['Signature']
+            if "Authorization" in header_params:
+                authVal= header_params['Authorization']
+            
+            header_params.update(self.mconfig.default_headers)
+            if(signVal is not None):
+                header_params['Signature']=signVal
+            if(authVal is not None):
+                header_params['Authorization']=authVal
+
         # perform request and return response
         response_data = self.request(method, url,
                                      query_params=query_params,

CyberSource/api_client.py

@@ -3,6 +3,7 @@
 # import apis into api package
 from .o_auth_api import OAuthApi
 from .asymmetric_key_management_api import AsymmetricKeyManagementApi
+from .batches_api import BatchesApi
 from .capture_api import CaptureApi
 from .chargeback_details_api import ChargebackDetailsApi
 from .chargeback_summaries_api import ChargebackSummariesApi
@@ -19,18 +20,19 @@
 from .interchange_clearing_level_details_api import InterchangeClearingLevelDetailsApi
 from .invoice_settings_api import InvoiceSettingsApi
 from .invoices_api import InvoicesApi
-from .key_generation_api import KeyGenerationApi
 from .keymanagement_api import KeymanagementApi
 from .keymanagementpassword_api import KeymanagementpasswordApi
 from .keymanagementpgp_api import KeymanagementpgpApi
 from .keymanagementscmp_api import KeymanagementscmpApi
+from .microform_integration_api import MicroformIntegrationApi
 from .net_fundings_api import NetFundingsApi
 from .notification_of_changes_api import NotificationOfChangesApi
 from .payer_authentication_api import PayerAuthenticationApi
 from .payment_batch_summaries_api import PaymentBatchSummariesApi
 from .payment_instrument_api import PaymentInstrumentApi
 from .payments_api import PaymentsApi
 from .payouts_api import PayoutsApi
+from .plans_api import PlansApi
 from .purchase_and_refund_details_api import PurchaseAndRefundDetailsApi
 from .push_funds_api import PushFundsApi
 from .refund_api import RefundApi
@@ -43,9 +45,10 @@
 from .reversal_api import ReversalApi
 from .search_transactions_api import SearchTransactionsApi
 from .secure_file_share_api import SecureFileShareApi
+from .subscriptions_api import SubscriptionsApi
 from .symmetric_key_management_api import SymmetricKeyManagementApi
 from .taxes_api import TaxesApi
-from .tokenization_api import TokenizationApi
+from .token_api import TokenApi
 from .transaction_batches_api import TransactionBatchesApi
 from .transaction_details_api import TransactionDetailsApi
 from .transient_token_data_api import TransientTokenDataApi

CyberSource/apis/__init__.py

@@ -67,7 +67,7 @@ def search_keys(self, **kwargs):
         :param list[str] key_types: Key Type, Possible values -  certificate, password, pgp and scmp_api. When Key Type is provided atleast one more filter needs to be provided
         :param datetime expiration_start_date: Expiry Filter Start Date. When Expiration Date filter is provided, atleast one more filter needs to be provided
         :param datetime expiration_end_date: Expiry Filter End Date. When Expiration Date filter is provided, atleast one more filter needs to be provided
-        :return: InlineResponse200
+        :return: InlineResponse20011
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -104,7 +104,7 @@ def search_keys_with_http_info(self, **kwargs):
         :param list[str] key_types: Key Type, Possible values -  certificate, password, pgp and scmp_api. When Key Type is provided atleast one more filter needs to be provided
         :param datetime expiration_start_date: Expiry Filter Start Date. When Expiration Date filter is provided, atleast one more filter needs to be provided
         :param datetime expiration_end_date: Expiry Filter End Date. When Expiration Date filter is provided, atleast one more filter needs to be provided
-        :return: InlineResponse200
+        :return: InlineResponse20011
                  If the method is called asynchronously,
                  returns the request thread.
         """
@@ -185,7 +185,7 @@ def search_keys_with_http_info(self, **kwargs):
                                         body=body_params,
                                         post_params=form_params,
                                         files=local_var_files,
-                                        response_type='InlineResponse200',
+                                        response_type='InlineResponse20011',
                                         auth_settings=auth_settings,
                                         callback=params.get('callback'),
                                         _return_http_data_only=params.get('_return_http_data_only'),

CyberSource/apis/batches_api.py

@@ -25,7 +25,7 @@
 import CyberSource.logging.log_factory as LogFactory
 
 
-class KeyGenerationApi(object):
+class MicroformIntegrationApi(object):
     """
     NOTE: This class is auto generated by the swagger code generator program.
     Do not edit the class manually.
@@ -45,59 +45,57 @@ def __init__(self, merchant_config, api_client=None):
 
 
 
-    def generate_public_key(self, format, generate_public_key_request, **kwargs):
+    def generate_capture_context(self, generate_capture_context_request, **kwargs):
         """
-        Generate Key
-        Generate a one-time use public key and key ID to encrypt the card number in the follow-on Tokenize Card request. The key used to encrypt the card number on the cardholder’s device or browser is valid for 15 minutes and must be used to verify the signature in the response message. CyberSource recommends creating a new key for each order. Generating a key is an authenticated request initiated from your servers, prior to requesting to tokenize the card data from your customer’s device or browser.
+        Generate Capture Context
+        This API is used to generate the Capture Context data structure for the Microform Integration.  Microform is a browser-based acceptance solution that allows a seller to capture payment information is a secure manner from their website.  For more information about Flex Microform transactions, see the [Flex Developer Guides Page](https://developer.cybersource.com/api/developer-guides/dita-flex/SAFlexibleToken.html). For examples on how to integrate Flex Microform within your webpage please see our [GitHub Flex Samples](https://github.com/CyberSource?q=flex&type=&language=) This API is a server-to-server API to generate the capture context that can be used to initiate instance of microform on a acceptance page.  The capture context is a digitally signed JWT that provides authentication, one-time keys, and the target origin to the Microform Integration application. 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please define a `callback` function
         to be invoked when receiving the response.
         >>> def callback_function(response):
         >>>     pprint(response)
         >>>
-        >>> thread = api.generate_public_key(format, generate_public_key_request, callback=callback_function)
+        >>> thread = api.generate_capture_context(generate_capture_context_request, callback=callback_function)
 
         :param callback function: The callback function
             for asynchronous request. (optional)
-        :param str format: Indicator to enable the receipt of the Keys response in Flex 11+ format (JWT) or legacy (parameter not required) (required)
-        :param GeneratePublicKeyRequest generate_public_key_request: (required)
-        :return: FlexV1KeysPost200Response
+        :param GenerateCaptureContextRequest generate_capture_context_request: (required)
+        :return: str
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
         if self.api_client.mconfig.log_config.enable_log:
-            self.logger.info("CALL TO METHOD `generate_public_key` STARTED")
+            self.logger.info("CALL TO METHOD `generate_capture_context` STARTED")
 
         kwargs['_return_http_data_only'] = True
         if kwargs.get('callback'):
-            return self.generate_public_key_with_http_info(format, generate_public_key_request, **kwargs)
+            return self.generate_capture_context_with_http_info(generate_capture_context_request, **kwargs)
         else:
-            (data) = self.generate_public_key_with_http_info(format, generate_public_key_request, **kwargs)
+            (data) = self.generate_capture_context_with_http_info(generate_capture_context_request, **kwargs)
             return data
 
-    def generate_public_key_with_http_info(self, format, generate_public_key_request, **kwargs):
+    def generate_capture_context_with_http_info(self, generate_capture_context_request, **kwargs):
         """
-        Generate Key
-        Generate a one-time use public key and key ID to encrypt the card number in the follow-on Tokenize Card request. The key used to encrypt the card number on the cardholder’s device or browser is valid for 15 minutes and must be used to verify the signature in the response message. CyberSource recommends creating a new key for each order. Generating a key is an authenticated request initiated from your servers, prior to requesting to tokenize the card data from your customer’s device or browser.
+        Generate Capture Context
+        This API is used to generate the Capture Context data structure for the Microform Integration.  Microform is a browser-based acceptance solution that allows a seller to capture payment information is a secure manner from their website.  For more information about Flex Microform transactions, see the [Flex Developer Guides Page](https://developer.cybersource.com/api/developer-guides/dita-flex/SAFlexibleToken.html). For examples on how to integrate Flex Microform within your webpage please see our [GitHub Flex Samples](https://github.com/CyberSource?q=flex&type=&language=) This API is a server-to-server API to generate the capture context that can be used to initiate instance of microform on a acceptance page.  The capture context is a digitally signed JWT that provides authentication, one-time keys, and the target origin to the Microform Integration application. 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please define a `callback` function
         to be invoked when receiving the response.
         >>> def callback_function(response):
         >>>     pprint(response)
         >>>
-        >>> thread = api.generate_public_key_with_http_info(format, generate_public_key_request, callback=callback_function)
+        >>> thread = api.generate_capture_context_with_http_info(generate_capture_context_request, callback=callback_function)
 
         :param callback function: The callback function
             for asynchronous request. (optional)
-        :param str format: Indicator to enable the receipt of the Keys response in Flex 11+ format (JWT) or legacy (parameter not required) (required)
-        :param GeneratePublicKeyRequest generate_public_key_request: (required)
-        :return: FlexV1KeysPost200Response
+        :param GenerateCaptureContextRequest generate_capture_context_request: (required)
+        :return: str
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
-        all_params = ['format', 'generate_public_key_request']
+        all_params = ['generate_capture_context_request']
         all_params.append('callback')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
@@ -108,41 +106,34 @@ def generate_public_key_with_http_info(self, format, generate_public_key_request
             if key not in all_params:
                 raise TypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method generate_public_key" % key
+                    " to method generate_capture_context" % key
                 )
             params[key] = val
         del params['kwargs']
-        # verify the required parameter 'format' is set
-        if ('format' not in params) or (params['format'] is None):
+        # verify the required parameter 'generate_capture_context_request' is set
+        if ('generate_capture_context_request' not in params) or (params['generate_capture_context_request'] is None):
             if self.api_client.mconfig.log_config.enable_log:
-                self.logger.error("InvalidArgumentException : Missing the required parameter `format` when calling `generate_public_key`")
-            raise ValueError("Missing the required parameter `format` when calling `generate_public_key`")
-        # verify the required parameter 'generate_public_key_request' is set
-        if ('generate_public_key_request' not in params) or (params['generate_public_key_request'] is None):
-            if self.api_client.mconfig.log_config.enable_log:
-                self.logger.error("InvalidArgumentException : Missing the required parameter `generate_public_key_request` when calling `generate_public_key`")
-            raise ValueError("Missing the required parameter `generate_public_key_request` when calling `generate_public_key`")
+                self.logger.error("InvalidArgumentException : Missing the required parameter `generate_capture_context_request` when calling `generate_capture_context`")
+            raise ValueError("Missing the required parameter `generate_capture_context_request` when calling `generate_capture_context`")
 
 
         collection_formats = {}
 
         path_params = {}
 
         query_params = []
-        if 'format' in params:
-            query_params.append(('format', params['format']))
 
         header_params = {}
 
         form_params = []
         local_var_files = {}
 
         body_params = None
-        if 'generate_public_key_request' in params:
-            body_params = params['generate_public_key_request']
+        if 'generate_capture_context_request' in params:
+            body_params = params['generate_capture_context_request']
         # HTTP header `Accept`
         header_params['Accept'] = self.api_client.\
-            select_header_accept(['application/json'])
+            select_header_accept(['application/jwt'])
 
         # HTTP header `Content-Type`
         header_params['Content-Type'] = self.api_client.\
@@ -151,14 +142,14 @@ def generate_public_key_with_http_info(self, format, generate_public_key_request
         # Authentication setting
         auth_settings = []
 
-        return self.api_client.call_api(f'/flex/v1/keys', 'POST',
+        return self.api_client.call_api(f'/microform/v2/sessions', 'POST',
                                         path_params,
                                         query_params,
                                         header_params,
                                         body=body_params,
                                         post_params=form_params,
                                         files=local_var_files,
-                                        response_type='FlexV1KeysPost200Response',
+                                        response_type='str',
                                         auth_settings=auth_settings,
                                         callback=params.get('callback'),
                                         _return_http_data_only=params.get('_return_http_data_only'),