connect-sdk-python2 3.45.0__zip → 3.47.0__zip

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

@@ -0,0 +1,406 @@
+from datetime import datetime
+from httplib import NOT_FOUND
+from urllib import quote
+from urlparse import urlparse
+
+from communication_exception import CommunicationException
+from ingenico.connect.sdk.log.logging_capable import LoggingCapable
+from ingenico.connect.sdk.log.obfuscation_capable import ObfuscationCapable
+from not_found_exception import NotFoundException
+from pooled_connection import PooledConnection
+from multipart_form_data_object import MultipartFormDataObject
+from multipart_form_data_request import MultipartFormDataRequest
+from request_header import RequestHeader
+from response_exception import ResponseException
+from response_header import get_header_value
+
+
+class Communicator(LoggingCapable, ObfuscationCapable):
+    """
+    Used to communicate with the Ingenico ePayments platform web services.
+
+    It contains all the logic to transform a request object to an HTTP request and an HTTP response to a response object.
+    """
+
+    def __init__(self, session, marshaller):
+        if session is None:
+            raise ValueError("session is required")
+        if marshaller is None:
+            raise ValueError("marshaller is required")
+        self.__session = session
+        self.__marshaller = marshaller
+
+    def close(self):
+        """
+        Releases any system resources associated with this object.
+        """
+        self.__session.connection.close()
+
+    def _get_with_binary_response(self, relative_path, request_headers, request_parameters, context):
+        connection = self.__session.connection
+        if request_parameters is None:
+            request_parameter_list = None
+        else:
+            request_parameter_list = request_parameters.to_request_parameters()
+        uri = self._to_absolute_uri(relative_path, request_parameter_list)
+        if request_headers is None:
+            request_headers = []
+        self._add_generic_headers("GET", uri, request_headers, context)
+
+        return connection.get(uri, request_headers)
+
+    def get_with_binary_response(self, relative_path, request_headers, request_parameters, context):
+        """
+        Corresponds to the HTTP GET method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._get_with_binary_response(relative_path, request_headers, request_parameters, context)
+        return self._process_binary_response(status, chunks, headers, relative_path, context)
+
+    def get(self, relative_path, request_headers, request_parameters, response_type, context):
+        """
+        Corresponds to the HTTP GET method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._get_with_binary_response(relative_path, request_headers, request_parameters, context)
+        return self._process_response(status, chunks, headers, relative_path, response_type, context)
+
+    def _delete_with_binary_response(self, relative_path, request_headers, request_parameters, context):
+        connection = self.__session.connection
+        if request_parameters is None:
+            request_parameter_list = None
+        else:
+            request_parameter_list = request_parameters.to_request_parameters()
+        uri = self._to_absolute_uri(relative_path, request_parameter_list)
+        if request_headers is None:
+            request_headers = []
+        self._add_generic_headers("DELETE", uri, request_headers, context)
+
+        return connection.delete(uri, request_headers)
+
+    def delete_with_binary_response(self, relative_path, request_headers, request_parameters, context):
+        """
+        Corresponds to the HTTP DELETE method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._delete_with_binary_response(relative_path, request_headers, request_parameters, context)
+        return self._process_binary_response(status, chunks, headers, relative_path, context)
+
+    def delete(self, relative_path, request_headers, request_parameters, response_type, context):
+        """
+        Corresponds to the HTTP DELETE method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._delete_with_binary_response(relative_path, request_headers, request_parameters, context)
+        return self._process_response(status, chunks, headers, relative_path, response_type, context)
+
+    def _post_with_binary_response(self, relative_path, request_headers, request_parameters, request_body, context):
+        connection = self.__session.connection
+        if request_parameters is None:
+            request_parameter_list = None
+        else:
+            request_parameter_list = request_parameters.to_request_parameters()
+        uri = self._to_absolute_uri(relative_path, request_parameter_list)
+        if request_headers is None:
+            request_headers = []
+
+        body = None
+        if isinstance(request_body, MultipartFormDataObject):
+            request_headers.append(RequestHeader("Content-Type", request_body.content_type))
+            body = request_body
+        elif isinstance(request_body, MultipartFormDataRequest):
+            multipart = request_body.to_multipart_form_data_object()
+            request_headers.append(RequestHeader("Content-Type", multipart.content_type))
+            body = multipart
+        elif request_body is not None:
+            request_headers.append(RequestHeader("Content-Type", "application/json"))
+            body = self.__marshaller.marshal(request_body)
+
+        self._add_generic_headers("POST", uri, request_headers, context)
+        return connection.post(uri, request_headers, body)
+
+    def post_with_binary_response(self, relative_path, request_headers, request_parameters, request_body, context):
+        """
+        Corresponds to the HTTP POST method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._post_with_binary_response(relative_path, request_headers, request_parameters, request_body, context)
+        return self._process_binary_response(status, chunks, headers, relative_path, context)
+
+    def post(self, relative_path, request_headers, request_parameters, request_body, response_type, context):
+        """
+        Corresponds to the HTTP POST method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._post_with_binary_response(relative_path, request_headers, request_parameters, request_body, context)
+        return self._process_response(status, chunks, headers, relative_path, response_type, context)
+
+    def _put_with_binary_response(self, relative_path, request_headers, request_parameters, request_body, context):
+        connection = self.__session.connection
+        if request_parameters is None:
+            request_parameter_list = None
+        else:
+            request_parameter_list = request_parameters.to_request_parameters()
+        uri = self._to_absolute_uri(relative_path, request_parameter_list)
+        if request_headers is None:
+            request_headers = []
+
+        body = None
+        if isinstance(request_body, MultipartFormDataObject):
+            request_headers.append(RequestHeader("Content-Type", request_body.content_type))
+            body = request_body
+        elif isinstance(request_body, MultipartFormDataRequest):
+            multipart = request_body.to_multipart_form_data_object()
+            request_headers.append(RequestHeader("Content-Type", multipart.content_type))
+            body = multipart
+        elif request_body is not None:
+            request_headers.append(RequestHeader("Content-Type", "application/json"))
+            body = self.__marshaller.marshal(request_body)
+
+        self._add_generic_headers("PUT", uri, request_headers, context)
+        return connection.put(uri, request_headers, body)
+
+    def put_with_binary_response(self, relative_path, request_headers, request_parameters, request_body, context):
+        """
+        Corresponds to the HTTP PUT method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._put_with_binary_response(relative_path, request_headers, request_parameters, request_body, context)
+        return self._process_binary_response(status, chunks, headers, relative_path, context)
+
+    def put(self, relative_path, request_headers, request_parameters, request_body, response_type, context):
+        """
+        Corresponds to the HTTP PUT method.
+
+        :param relative_path: The path to call, relative to the base URI.
+        :param request_headers: An optional list of request headers.
+        :param request_parameters: An optional set of request parameters.
+        :param request_body: The optional request body to send.
+        :param response_type: The type of response to return.
+        :param context: The optional call context to use.
+        :raise: CommunicationException when an exception occurred communicating with the Ingenico ePayments platform
+        :raise: ResponseException when an error response was received from the Ingenico ePayments platform
+        :raise: ApiException when an error response was received from the Ingenico ePayments platform which contained a list of errors
+        """
+        (status, headers, chunks) = self._put_with_binary_response(relative_path, request_headers, request_parameters, request_body, context)
+        return self._process_response(status, chunks, headers, relative_path, response_type, context)
+
+    @property
+    def marshaller(self):
+        """
+        :return: The Marshaller object associated with this communicator. Never None.
+        """
+        return self.__marshaller
+
+    def _to_absolute_uri(self, relative_path, request_parameters):
+        api_endpoint = self.__session.api_endpoint
+        if api_endpoint.path:
+            raise ValueError("api_endpoint should not contain a path")
+        if api_endpoint.username is not None or api_endpoint.query or api_endpoint.fragment:
+            raise ValueError("api_endpoint should not contain user info, query or fragment")
+        if relative_path.startswith("/"):
+            absolute_path = relative_path
+        else:
+            absolute_path = "/" + relative_path
+        uri = api_endpoint.geturl() + absolute_path
+        separator = "?"
+        if request_parameters is not None:
+            for nvp in request_parameters:
+                uri += separator
+                uri += quote(nvp.name) + "=" + quote(nvp.value)
+                separator = "&"
+        # no need to revalidate that uri has a valid scheme and netloc
+        return urlparse(uri)
+
+    def _add_generic_headers(self, http_method, uri, request_headers, context):
+        """
+        Adds the necessary headers to the given list of headers. This includes
+        the authorization header, which uses other headers, so when you need to
+        override this method, make sure to call super.addGenericHeaders at the
+        end of your overridden method.
+        """
+        # add server meta info header
+        request_headers.extend(self.__session.meta_data_provider.meta_data_headers)
+        # add date header
+        request_headers.append(RequestHeader("Date", self._get_header_date_string()))
+        if context is not None and context.idempotence_key is not None:
+            # add context specific headers
+            request_headers.append(RequestHeader("X-GCS-Idempotence-Key", context.idempotence_key))
+        # add signature
+        authenticator = self.__session.authenticator
+        authentication_signature = authenticator.create_simple_authentication_signature(http_method, uri, request_headers)
+        request_headers.append(RequestHeader("Authorization", authentication_signature))
+
+    def _get_header_date_string(self):
+        """
+        Returns the date in the preferred format for the HTTP date header.
+        """
+        date_format_utc = datetime.utcnow().strftime(
+            "%a, %d %b %Y %H:%M:%S GMT")
+        return date_format_utc
+
+    @staticmethod
+    def __collect_chunks(chunks):
+        collected_body = b""
+        for chunk in chunks:
+            collected_body += chunk
+        return collected_body.decode('utf-8')
+
+    def _process_binary_response(self, status, chunks, headers, request_path, context):
+        if context is not None:
+            self._update_context(headers, context)
+        self._throw_exception_if_necessary_binary(status, chunks, headers, request_path)
+        return headers, chunks
+
+    def _process_response(self, status, chunks, headers, request_path, response_type, context):
+        if context is not None:
+            self._update_context(headers, context)
+        body = self.__collect_chunks(chunks)
+        self._throw_exception_if_necessary(status, body, headers, request_path)
+        return self.__marshaller.unmarshal(body, response_type)
+
+    def _update_context(self, headers, context):
+        """
+        Updates the given call context based on the contents of the given response.
+        """
+        idempotence_request_timestamp_value = get_header_value(headers, "X-GCS-Idempotence-Request-Timestamp")
+        if idempotence_request_timestamp_value is not None:
+            idempotence_request_timestamp = long(idempotence_request_timestamp_value)
+            context.idempotence_request_timestamp = idempotence_request_timestamp
+        else:
+            context.idempotence_request_timestamp = None
+
+    def _throw_exception_if_necessary_binary(self, status, chunks, headers, request_path):
+        """
+        Checks the Response for errors and throws an exception if necessary.
+        """
+        # status codes in the 100 or 300 range are not expected
+        if status < 200 or status >= 300:
+            body = self.__collect_chunks(chunks)
+            self.__throw_exception(status, body, headers, request_path)
+
+    def _throw_exception_if_necessary(self, status, body, headers, request_path):
+        """
+        Checks the Response for errors and throws an exception if necessary.
+        """
+        # status codes in the 100 or 300 range are not expected
+        if status < 200 or status >= 300:
+            self.__throw_exception(status, body, headers, request_path)
+
+    def __throw_exception(self, status, body, headers, request_path):
+        if body is not None and not self.__is_json(headers):
+            cause = ResponseException(status, body, headers)
+            if status == NOT_FOUND:
+                raise NotFoundException(cause, "The requested resource was not found; invalid path: " + request_path)
+            else:
+                raise CommunicationException(cause)
+        else:
+            raise ResponseException(status, body, headers)
+
+    @staticmethod
+    def __is_json(headers):
+        content_type = get_header_value(headers, "Content-Type")
+        return (content_type is None) or \
+               ("application/json".lower() == content_type) or \
+               (content_type.lower().startswith("application/json"))
+
+    def close_idle_connections(self, idle_time):
+        """
+        Utility method that delegates the call to this communicator's session's
+        connection if that's an instance of PooledConnection. If not this method
+        does nothing.
+
+        :param idle_time: a datetime.timedelta object indicating the idle time
+        """
+        connection = self.__session.connection
+        if isinstance(connection, PooledConnection):
+            connection.close_idle_connections(idle_time)
+
+    def close_expired_connections(self):
+        """
+        Utility method that delegates the call to this communicator's session's
+        connection if that's an instance of PooledConnection. If not this method
+        does nothing.
+        """
+        connection = self.__session.connection
+        if isinstance(connection, PooledConnection):
+            connection.close_expired_connections()
+
+    def set_body_obfuscator(self, body_obfuscator):
+        connection = self.__session.connection
+        if isinstance(connection, ObfuscationCapable):
+            connection.set_body_obfuscator(body_obfuscator)
+
+    def set_header_obfuscator(self, header_obfuscator):
+        connection = self.__session.connection
+        if isinstance(connection, ObfuscationCapable):
+            connection.set_header_obfuscator(header_obfuscator)
+
+    def enable_logging(self, communicator_logger):
+        # delegate to the connection
+        self.__session.connection.enable_logging(communicator_logger)
+
+    def disable_logging(self):
+        # delegate to the connection
+        self.__session.connection.disable_logging()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

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

@@ -0,0 +1,94 @@
+from endpoint_configuration import EndpointConfiguration
+from ingenico.connect.sdk.defaultimpl.authorization_type import AuthorizationType
+
+
+# pylint: disable=too-many-instance-attributes
+# Necessary to load information from config
+class CommunicatorConfiguration(EndpointConfiguration):
+    """
+    Configuration for the communicator.
+
+    :param properties: a ConfigParser.ConfigParser object containing configuration data
+    :param connect_timeout: connection timeout for the network communication in seconds
+    :param socket_timeout: socket timeout for the network communication in seconds
+    :param max_connections: The maximum number of connections in the connection pool
+    """
+    __api_key_id = None
+    __secret_api_key = None
+
+    def __init__(self, properties=None, api_endpoint=False, api_key_id=False,
+                 secret_api_key=False, authorization_type=False,
+                 connect_timeout=False, socket_timeout=False,
+                 max_connections=False, proxy_configuration=False,
+                 integrator=False, shopping_cart_extension=False):
+        if properties:
+            super(CommunicatorConfiguration, self).__init__(properties, "connect.api")
+            if properties.sections() and properties.options("ConnectSDK"):
+                authorization = properties.get("ConnectSDK", "connect.api.authorizationType")
+                self.__authorization_type = AuthorizationType.get_authorization(authorization)
+        if api_endpoint:
+            self.api_endpoint = api_endpoint
+        if api_key_id:
+            self.api_key_id = api_key_id
+        if secret_api_key:
+            self.secret_api_key = secret_api_key
+        if authorization_type:
+            self.authorization_type = authorization_type
+        if connect_timeout:
+            self.connect_timeout = connect_timeout
+        if socket_timeout:
+            self.socket_timeout = socket_timeout
+        if max_connections:
+            self.max_connections = max_connections
+        if proxy_configuration:
+            self.proxy_configuration = proxy_configuration
+        if integrator:
+            self.integrator = integrator
+        if shopping_cart_extension:
+            self.shopping_cart_extension = shopping_cart_extension
+
+    @property
+    def api_endpoint(self):
+        """
+        The Ingenico ePayments platform API endpoint URI.
+        """
+        return super(CommunicatorConfiguration, self)._endpoint
+
+    @api_endpoint.setter
+    def api_endpoint(self, api_endpoint):
+        super(CommunicatorConfiguration, self)._set_endpoint(api_endpoint)
+
+    @property
+    def api_key_id(self):
+        """
+        An identifier for the secret API key. The api_key_id can be
+        retrieved from the Configuration Center. This identifier is visible in
+        the HTTP request and is also used to identify the correct account.
+        """
+        return self.__api_key_id
+
+    @api_key_id.setter
+    def api_key_id(self, api_key_id):
+        self.__api_key_id = api_key_id
+
+    @property
+    def secret_api_key(self):
+        """
+        A shared secret. The shared secret can be retrieved from the
+        Configuration Center. An api_key_id and secret_api_key always go
+        hand-in-hand, the difference is that secret_api_key is never visible in
+        the HTTP request. This secret is used as input for the HMAC algorithm.
+        """
+        return self.__secret_api_key
+
+    @secret_api_key.setter
+    def secret_api_key(self, secret_api_key):
+        self.__secret_api_key = secret_api_key
+
+    @property
+    def authorization_type(self):
+        return self.__authorization_type
+
+    @authorization_type.setter
+    def authorization_type(self, authorization_type):
+        self.__authorization_type = authorization_type

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

@@ -0,0 +1,68 @@
+from ingenico.connect.sdk.log.logging_capable import LoggingCapable
+
+
+# noinspection PyAbstractClass
+class Connection(LoggingCapable):
+    """
+    Represents a connection to the Ingenico ePayments platform server.
+    """
+
+    def get(self, url, request_headers):
+        """
+        Send a GET request to the Ingenico ePayments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :return: The response from the Ingenico ePayments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise: CommunicationException when an exception occurred communicating
+         with the Ingenico ePayments platform
+        """
+        raise NotImplementedError
+
+    def delete(self, url, request_headers):
+        """
+        Send a DELETE request to the Ingenico ePayments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :return: The response from the Ingenico ePayments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise: CommunicationException when an exception occurred communicating
+         with the Ingenico ePayments platform
+        """
+        raise NotImplementedError
+
+    def post(self, url, request_headers, body):
+        """
+        Send a POST request to the Ingenico ePayments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :param body: The optional body to send.
+        :return: The response from the Ingenico ePayments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise: CommunicationException when an exception occurred communicating
+         with the Ingenico ePayments platform
+        """
+        raise NotImplementedError
+
+    def put(self, url, request_headers, body):
+        """
+        Send a PUT request to the Ingenico ePayments platform and return the response.
+
+        :param url: The URI to call, including any necessary query parameters.
+        :param request_headers: An optional sequence of request headers.
+        :param body: The optional body to send.
+        :return: The response from the Ingenico ePayments platform as a tuple with
+         the status code, headers and a generator of body chunks
+        :raise: CommunicationException when an exception occurred communicating
+         with the Ingenico ePayments platform
+        """
+        raise NotImplementedError
+
+    def close(self):
+        """
+        Releases any system resources associated with this object.
+        """
+        pass

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

@@ -0,0 +1,8 @@
+class DataObject(object):
+    def to_dictionary(self):
+        return {}
+
+    def from_dictionary(self, dictionary):
+        if not isinstance(dictionary, dict):
+            raise TypeError('value \'{}\' is not a dictionary'.format(dictionary))
+        return self

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

@@ -0,0 +1,37 @@
+from declined_transaction_exception import DeclinedTransactionException
+
+
+class DeclinedPaymentException(DeclinedTransactionException):
+    """
+    Represents an error response from a create payment call.
+    """
+
+    def __init__(self, status_code, response_body, errors):
+        if errors is not None:
+            super(DeclinedPaymentException, self).__init__(status_code, response_body, errors.error_id, errors.errors,
+                                                           DeclinedPaymentException.__create_message(errors))
+        else:
+            super(DeclinedPaymentException, self).__init__(status_code, response_body, None, None,
+                                                           DeclinedPaymentException.__create_message(errors))
+        self.__errors = errors
+
+    @staticmethod
+    def __create_message(errors):
+        if errors is not None and errors.payment_result is not None:
+            payment = errors.payment_result.payment
+        else:
+            payment = None
+        if payment is not None:
+            return "declined payment '" + payment.id + "' with status '" + payment.status + "'"
+        else:
+            return "the Ingenico ePayments platform returned a declined payment response"
+
+    @property
+    def create_payment_result(self):
+        """
+        :return: The result of creating a payment if available, otherwise None.
+        """
+        if self.__errors is None:
+            return None
+        else:
+            return self.__errors.payment_result

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

@@ -0,0 +1,37 @@
+from declined_transaction_exception import DeclinedTransactionException
+
+
+class DeclinedPayoutException(DeclinedTransactionException):
+    """
+    Represents an error response from a payout call.
+    """
+
+    def __init__(self, status_code, response_body, errors):
+        if errors is not None:
+            super(DeclinedPayoutException, self).__init__(status_code, response_body, errors.error_id, errors.errors,
+                                                          DeclinedPayoutException.__create_message(errors))
+        else:
+            super(DeclinedPayoutException, self).__init__(status_code, response_body, None, None,
+                                                          DeclinedPayoutException.__create_message(errors))
+        self.__errors = errors
+
+    @staticmethod
+    def __create_message(errors):
+        if errors is not None:
+            payout = errors.payout_result
+        else:
+            payout = None
+        if payout is not None:
+            return "declined payout '" + payout.id + "' with status '" + payout.status + "'"
+        else:
+            return "the Ingenico ePayments platform returned a declined payout response"
+
+    @property
+    def payout_result(self):
+        """
+        :return: The result of creating a payout if available, otherwise None.
+        """
+        if self.__errors is None:
+            return None
+        else:
+            return self.__errors.payout_result