connect-sdk-python2 3.45.0__zip → 3.47.0__zip

connect-sdk-python2-3.47.0/ingenico/connect/sdk/factory.py

@@ -0,0 +1,130 @@
+from ConfigParser import ConfigParser
+
+from communicator import Communicator
+from communicator_configuration import CommunicatorConfiguration
+from client import Client
+from meta_data_provider import MetaDataProvider
+from session import Session
+from ingenico.connect.sdk.defaultimpl.default_authenticator import DefaultAuthenticator
+from ingenico.connect.sdk.defaultimpl.default_connection import DefaultConnection
+from ingenico.connect.sdk.defaultimpl.default_marshaller import DefaultMarshaller
+
+
+class Factory:
+    """
+    Ingenico ePayments platform factory for several SDK components.
+    """
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def create_configuration(configuration_file_name, api_key_id, secret_api_key):
+        """
+        Creates a CommunicatorConfiguration based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
+        """
+        try:
+            parser = ConfigParser()
+            parser.read(configuration_file_name)
+            with open(configuration_file_name) as f:
+                parser.readfp(f)
+            return CommunicatorConfiguration(properties=parser,
+                                             api_key_id=api_key_id,
+                                             secret_api_key=secret_api_key)
+        except IOError as e:
+            raise RuntimeError("Unable to read configuration located at {}".format(e.filename), e)
+
+    @staticmethod
+    def create_session_from_configuration(communicator_configuration,
+                                          meta_data_provider=None,
+                                          connection=None,
+                                          authenticator=None):
+        """
+        Creates a Session based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        # If an authenticator is not given, api_key_id and secret_api_key are used to create a DefaultAuthenticator used to create the session.
+        if meta_data_provider is None:
+            meta_data_provider = MetaDataProvider(integrator=communicator_configuration.integrator,
+                                                  shopping_cart_extension=communicator_configuration.shopping_cart_extension)
+        if connection is None:
+            connection = DefaultConnection(communicator_configuration.connect_timeout,
+                                           communicator_configuration.socket_timeout,
+                                           communicator_configuration.max_connections,
+                                           communicator_configuration.proxy_configuration)
+        if authenticator is None:
+            authenticator = DefaultAuthenticator(communicator_configuration.authorization_type,
+                                                 communicator_configuration.api_key_id,
+                                                 communicator_configuration.secret_api_key)
+        return Session(api_endpoint=communicator_configuration.api_endpoint,
+                       meta_data_provider=meta_data_provider,
+                       connection=connection,
+                       authenticator=authenticator)
+
+    @staticmethod
+    def create_session_from_file(configuration_file_name, api_key_id, secret_api_key,
+                                 meta_data_provider=None,
+                                 connection=None,
+                                 authenticator=None):
+        """
+        Creates a Session based on the configuration values in configuration_file_name, api_id_key and secret_api_key.
+        """
+        configuration = Factory.create_configuration(configuration_file_name, api_key_id, secret_api_key)
+        return Factory.create_session_from_configuration(configuration,
+                                                         meta_data_provider=meta_data_provider,
+                                                         connection=connection,
+                                                         authenticator=authenticator)
+
+    @staticmethod
+    def create_communicator_from_session(session):
+        """
+        Create a Communicator based on the settings stored in the Session argument
+        """
+        return Communicator(session, DefaultMarshaller.INSTANCE())
+
+    @staticmethod
+    def create_communicator_from_configuration(communicator_configuration):
+        """
+        Create a Communicator based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        session = Factory.create_session_from_configuration(communicator_configuration)
+        return Communicator(session, DefaultMarshaller.INSTANCE())
+
+    @staticmethod
+    def create_communicator_from_file(configuration_file_name, api_key_id, secret_api_key):
+        """
+        Creates a Communicator based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
+        """
+        configuration = Factory.create_configuration(configuration_file_name, api_key_id, secret_api_key)
+        session = Factory.create_session_from_configuration(configuration)
+        return Communicator(session, DefaultMarshaller.INSTANCE())
+
+    @staticmethod
+    def create_client_from_configuration(communicator_configuration):
+        """
+        Create a Client based on the configuration stored in the CommunicatorConfiguration argument
+        """
+        communicator = Factory.create_communicator_from_configuration(communicator_configuration)
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_communicator(communicator):
+        """
+        Create a Client based on the settings stored in the Communicator argument
+        """
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_session(session):
+        """
+        Create a Client based on the settings stored in the Session argument
+        """
+        communicator = Factory.create_communicator_from_session(session)
+        return Client(communicator)
+
+    @staticmethod
+    def create_client_from_file(configuration_file_name, api_key_id, secret_api_key):
+        """
+        Creates a Client based on the configuration values in configuration_file_name, api_key_id and secret_api_key.
+        """
+        communicator = Factory.create_communicator_from_file(configuration_file_name, api_key_id, secret_api_key)
+        return Client(communicator)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/global_collect_exception.py

@@ -0,0 +1,12 @@
+from api_exception import ApiException
+
+
+class GlobalCollectException(ApiException):
+    """
+    Represents an error response from the Ingenico ePayments platform when something
+    went wrong at the Ingenico ePayments platform or further downstream.
+    """
+
+    def __init__(self, status_code, response_body, error_id, errors,
+                 message="the Ingenico ePayments platform returned an error response"):
+        super(GlobalCollectException, self).__init__(status_code, response_body, error_id, errors, message)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/idempotence_exception.py

@@ -0,0 +1,29 @@
+from api_exception import ApiException
+
+
+class IdempotenceException(ApiException):
+    """
+    Represents an error response from the Ingenico ePayments platform when an
+    idempotent request failed because the first request has not finished yet.
+    """
+
+    def __init__(self, idempotence_key, idempotence_request_timestamp,
+                 status_code, response_body, error_id, errors,
+                 message="the Ingenico ePayments platform returned a duplicate request error response"):
+        super(IdempotenceException, self).__init__(status_code, response_body, error_id, errors, message)
+        self.__idempotence_key = idempotence_key
+        self.__idempotence_request_timestamp = idempotence_request_timestamp
+
+    @property
+    def idempotence_key(self):
+        """
+        :return: The key that was used for the idempotent request.
+        """
+        return self.__idempotence_key
+
+    @property
+    def idempotence_request_timestamp(self):
+        """
+        :return: The request timestamp of the first idempotent request with the same key.
+        """
+        return self.__idempotence_request_timestamp

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/log_message.py

@@ -0,0 +1,89 @@
+from body_obfuscator import BodyObfuscator
+from header_obfuscator import HeaderObfuscator
+
+
+class LogMessage(object):
+    """
+    A utility class to build log messages.
+    """
+    __request_id = None
+    __headers = None
+    __body = None
+    __content_type = None
+    __header_list = None
+    __body_obfuscator = None
+    __header_obfuscator = None
+
+    def __init__(self, request_id,
+                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
+        if not request_id:
+            raise ValueError("request_id is required")
+        if not body_obfuscator:
+            raise ValueError("body_obfuscator is required")
+        if not header_obfuscator:
+            raise ValueError("header_obfuscator is required")
+        self.__request_id = request_id
+        self.__headers = ""
+        self.__header_list = []
+        self.__body_obfuscator = body_obfuscator
+        self.__header_obfuscator = header_obfuscator
+
+    @property
+    def request_id(self):
+        return self.__request_id
+
+    @property
+    def headers(self):
+        return str(self.__headers)
+
+    @property
+    def body(self):
+        return self.__body
+
+    @property
+    def content_type(self):
+        return self.__content_type
+
+    def add_header(self, name, value):
+        if self.__headers:
+            self.__headers += ", "
+        self.__headers += name + "=\""
+        if value is not None and value.lower() != 'none':
+            obfuscated_value = self.__header_obfuscator.obfuscate_header(name, value)
+            self.__headers += obfuscated_value
+            self.__header_list.append((name, "\"" + obfuscated_value + "\""))
+        else:
+            self.__header_list.append((name, "\"\""))
+        self.__headers += "\""
+
+    def set_body(self, body, content_type, charset=None):
+        self.__content_type = content_type
+        if self.__is_binary(content_type):
+            self.__body = "<binary content>"
+        else:
+            self.__body = self.__body_obfuscator.obfuscate_body(body, charset)
+
+    def set_binary_body(self, content_type):
+        if not self.__is_binary(content_type):
+            raise ValueError("Not a binary content type: " + content_type)
+        self.__content_type = content_type
+        self.__body = "<binary content>"
+
+    @staticmethod
+    def __is_binary(content_type):
+        if content_type is None:
+            return False
+        content_type = content_type.lower()
+        return not (content_type.startswith("text/") or "json" in content_type or "xml" in content_type)
+
+    def empty_if_none(self, value):
+        if value is not None:
+            return value
+        return ""
+
+    def get_message(self):
+        raise NotImplementedError
+
+    def get_header_list(self):
+        return self.__header_list

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/python_communicator_logger.py

@@ -0,0 +1,51 @@
+from communicator_logger import CommunicatorLogger
+
+
+class PythonCommunicatorLogger(CommunicatorLogger):
+    """
+    A communicator logger that is backed by the log library.
+    """
+
+    def __init__(self, logger, log_level, error_log_level=False):
+        """
+        Logs messages to the argument logger using the argument log_level.
+        If absent, the error_log_level will be equal to the log_level.
+        Note that if the CommunicatorLogger's log level is lower than the
+        argument logger's log level (e.g. the CommunicatorLogger is given
+        log.INFO as level and the argument logger has a level of
+        log.WARNING), then nothing will be logged to the logger.
+
+        :param logger: the logger to log to
+        :param log_level: the log level that will be used for non-error
+         messages logged via the CommunicatorLogger
+        :param error_log_level: the log level that will be used for error
+         messages logged via the CommunicatorLogger.
+        """
+        CommunicatorLogger.__init__(self)
+        if not error_log_level:
+            error_log_level = log_level
+        if logger is None:
+            raise ValueError("logger is required")
+        if log_level is None:
+            raise ValueError("log_level is required")
+        if error_log_level is None:
+            raise ValueError("error_log_level is required")
+        self.__logger = logger
+        self.__log_level = log_level
+        self.__error_log_level = error_log_level
+
+    def log(self, message, thrown=None):
+        """
+        Log a message to the underlying logger.
+        If thrown is absent, the message will be logged with the
+        CommunicatorLogger's log_level, if a thrown object is provided,
+        the message and exception will be logged with the CommunicatorLogger's
+        error_log_level.
+
+        :param message: the message to be logged
+        :param thrown: an optional throwable object
+        """
+        if not thrown:
+            self.__logger.log(self.__log_level, message)
+        else:
+            self.__logger.log(self.__error_log_level, message, thrown)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/request_log_message.py

@@ -0,0 +1,28 @@
+from body_obfuscator import BodyObfuscator
+from header_obfuscator import HeaderObfuscator
+from log_message import LogMessage
+
+
+class RequestLogMessage(LogMessage):
+    """
+    A utility class to build request log messages.
+    """
+
+    def __init__(self, request_id, method, uri,
+                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
+        super(RequestLogMessage, self).__init__(request_id, body_obfuscator, header_obfuscator)
+        self.method = method
+        self.uri = uri
+
+    def get_message(self):
+        string = "Outgoing request (requestId='" + str(self.request_id) + "'):\n" + \
+                 "  method:       " + self.empty_if_none("'" + self.method + "'") + "\n" + \
+                 "  uri:          " + self.empty_if_none("'" + self.uri + "'") + "\n" + \
+                 "  headers:      " + self.headers
+        body = self.body
+        if body is None:
+            return string
+        else:
+            return string + "\n  content-type: '" + self.empty_if_none(self.content_type) + "'\n" + \
+                   "  body:         '" + body + "'"

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/response_log_message.py

@@ -0,0 +1,40 @@
+from body_obfuscator import BodyObfuscator
+from header_obfuscator import HeaderObfuscator
+from log_message import LogMessage
+
+
+class ResponseLogMessage(LogMessage):
+    """
+    A utility class to build request log messages.
+    """
+
+    def __init__(self, request_id, status_code, duration=-1,
+                 body_obfuscator=BodyObfuscator.default_body_obfuscator(),
+                 header_obfuscator=HeaderObfuscator.default_header_obfuscator()):
+        super(ResponseLogMessage, self).__init__(request_id, body_obfuscator, header_obfuscator)
+        self.__status_code = status_code
+        if duration is False:
+            self.__duration = -1
+        else:
+            self.__duration = duration
+
+    def get_duration(self):
+        return self.__duration
+
+    def get_status_code(self):
+        return self.__status_code
+
+    def get_message(self):
+        if self.__duration < 0:
+            return "Incoming response (requestId='" + self.request_id + "'):\n" + \
+                   "  status_code:  " + str(self.__status_code) + "\n" + \
+                   "  headers:      " + self.headers + "\n" + \
+                   "  content-type: " + self.empty_if_none(self.content_type) + "\n" + \
+                   "  body:         " + self.empty_if_none(self.body)
+
+        else:
+            return "Incoming response (requestId='" + self.request_id + "', " + str(self.__duration) + " ms):\n" + \
+                   "  status_code:  " + str(self.__status_code) + "\n" + \
+                   "  headers:      " + self.headers + "\n" + \
+                   "  content-type: " + self.empty_if_none(self.content_type) + "\n" + \
+                   "  body:         " + self.empty_if_none(self.body).encode('utf-8', errors='backslashreplace')

connect-sdk-python2-3.47.0/ingenico/connect/sdk/log/sys_out_communicator_logger.py

@@ -0,0 +1,40 @@
+from __future__ import print_function
+
+from datetime import datetime
+from threading import Lock
+
+from ingenico.connect.sdk.log.python_communicator_logger import CommunicatorLogger
+
+
+class SysOutCommunicatorLogger(CommunicatorLogger):
+    """
+    A communicator logger that prints its message to sys.stdout
+    It includes a timestamp in yyyy-MM-ddTHH:mm:ss format in the system time zone.
+    """
+
+    def __init__(self):
+        CommunicatorLogger.__init__(self)
+
+    _global_lock = Lock()
+    _old_print = print
+
+    @staticmethod
+    def INSTANCE():
+        return _SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE
+
+    def __print(self, *a):
+        with self._global_lock:
+            self._old_print(*a)
+
+    def log(self, message, thrown=None):
+        # Make sure the same object is used for locking and printing
+        self.__print(self.__get_date_prefix() + message)
+        if thrown:
+            self.__print(str(thrown))
+
+    @staticmethod
+    def __get_date_prefix():
+        return datetime.now().strftime("%Y-%m-%dT%H:%M:%S ")
+
+
+_SYS_OUT_COMMUNICATOR_LOGGER_INSTANCE = SysOutCommunicatorLogger()

connect-sdk-python2-3.47.0/ingenico/connect/sdk/marshaller.py

@@ -0,0 +1,23 @@
+class Marshaller(object):
+    """
+    Used to marshal and unmarshal Ingenico ePayments platform request and response objects to and from JSON.
+    """
+
+    def marshal(self, request_object):
+        """
+        Marshal a request object to a JSON string.
+
+        :param request_object: the object to marshal into a serialized JSON string
+        :return: the serialized JSON string of the request_object
+        """
+        raise NotImplementedError
+
+    def unmarshal(self, response_json, type_class):
+        """
+        Unmarshal a JSON string to a response object.
+
+        :param response_json: the json body that should be unmarshalled
+        :param type_class: The class to which the response_json should be unmarshalled
+        :raise: MarshallerSyntaxException if the JSON is not a valid representation for an object of the given type
+        """
+        raise NotImplementedError

connect-sdk-python2-3.47.0/ingenico/connect/sdk/merchant/__init__.py

@@ -0,0 +1,4 @@
+#
+# This file was auto-generated from the API references found at
+# https://epayments-api.developer-ingenico.com
+#

connect-sdk-python2-3.47.0/ingenico/connect/sdk/merchant/captures/__init__.py

@@ -0,0 +1,4 @@
+#
+# This file was auto-generated from the API references found at
+# https://epayments-api.developer-ingenico.com
+#

connect-sdk-python2-3.47.0/ingenico/connect/sdk/merchant/captures/captures_client.py

@@ -0,0 +1,96 @@
+#
+# This class was auto-generated from the API references found at
+# https://epayments-api.developer-ingenico.com/
+#
+from ingenico.connect.sdk.api_resource import ApiResource
+from ingenico.connect.sdk.response_exception import ResponseException
+from ingenico.connect.sdk.domain.capture.capture_response import CaptureResponse
+from ingenico.connect.sdk.domain.errors.error_response import ErrorResponse
+from ingenico.connect.sdk.domain.refund.refund_error_response import RefundErrorResponse
+from ingenico.connect.sdk.domain.refund.refund_response import RefundResponse
+
+
+class CapturesClient(ApiResource):
+    """
+    Captures client. Thread-safe.
+    """
+
+    def __init__(self, parent, path_context):
+        """
+        :param parent:       :class:`ingenico.connect.sdk.api_resource.ApiResource`
+        :param path_context: dict[str, str]
+        """
+        super(CapturesClient, self).__init__(parent, path_context)
+
+    def get(self, capture_id, context=None):
+        """
+        Resource /{merchantId}/captures/{captureId} - Get capture
+        
+        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/captures/get.html
+
+        :param capture_id:  str
+        :param context:     :class:`ingenico.connect.sdk.call_context.CallContext`
+        :return: :class:`ingenico.connect.sdk.domain.capture.capture_response.CaptureResponse`
+        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
+        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
+                   the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise: ApiException if the Ingenico ePayments platform returned any other error
+        """
+        path_context = {
+            "captureId": capture_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}", path_context)
+        try:
+            return self._communicator.get(
+                    uri,
+                    self._client_headers,
+                    None,
+                    CaptureResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = ErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise self._create_exception(e.status_code, e.body, error_object, context)
+
+    def refund(self, capture_id, body, context=None):
+        """
+        Resource /{merchantId}/captures/{captureId}/refund - Create Refund
+        
+        See also https://epayments-api.developer-ingenico.com/s2sapi/v1/en_US/python/captures/refund.html
+
+        :param capture_id:  str
+        :param body:        :class:`ingenico.connect.sdk.domain.refund.refund_request.RefundRequest`
+        :param context:     :class:`ingenico.connect.sdk.call_context.CallContext`
+        :return: :class:`ingenico.connect.sdk.domain.refund.refund_response.RefundResponse`
+        :raise: DeclinedRefundException if the Ingenico ePayments platform declined / rejected the refund. The refund result will be available from the exception.
+        :raise: ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
+        :raise: AuthorizationException if the request was not allowed (HTTP status code 403)
+        :raise: ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
+                   or there was a conflict (HTTP status code 404, 409 or 410)
+        :raise: GlobalCollectException if something went wrong at the Ingenico ePayments platform,
+                   the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
+                   or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
+        :raise: ApiException if the Ingenico ePayments platform returned any other error
+        """
+        path_context = {
+            "captureId": capture_id,
+        }
+        uri = self._instantiate_uri("/v1/{merchantId}/captures/{captureId}/refund", path_context)
+        try:
+            return self._communicator.post(
+                    uri,
+                    self._client_headers,
+                    None,
+                    body,
+                    RefundResponse,
+                    context)
+
+        except ResponseException as e:
+            error_type = RefundErrorResponse
+            error_object = self._communicator.marshaller.unmarshal(e.body, error_type)
+            raise self._create_exception(e.status_code, e.body, error_object, context)

connect-sdk-python2-3.47.0/ingenico/connect/sdk/merchant/disputes/__init__.py

@@ -0,0 +1,4 @@
+#
+# This file was auto-generated from the API references found at
+# https://epayments-api.developer-ingenico.com
+#