Base excaption handler done.

Author: Kevin Hellemun

bunq/sdk/client.py

@@ -6,6 +6,7 @@
 
 from bunq.sdk import context
 from bunq.sdk import exception
+from bunq.sdk.exception_hanlder import ExceptionHandler
 from bunq.sdk import security
 from bunq.sdk.json import converter
 
@@ -201,11 +202,17 @@ def _assert_response_success(self, response):
         """
 
         if response.status_code != self._STATUS_CODE_OK:
-            raise exception.ApiException(
+            exception_ = ExceptionHandler.create_exception_for_response(
                 response.status_code,
                 self._fetch_error_messages(response)
             )
 
+            raise exception_
+            # raise exception.ApiException(
+            #     response.status_code,
+            #     self._fetch_error_messages(response)
+            # )
+
     @classmethod
     def _create_bunq_response_raw(cls, response):
         """

bunq/sdk/exception.py

@@ -1,54 +1,52 @@
-class ApiException(Exception):
-    """
-    :type _response_code: int
-    """
-
-    # Constants for formatting messages
-    _FORMAT_RESPONSE_CODE_LINE = 'HTTP Response Code: {}'
-    _GLUE_ERROR_MESSAGES = '\n'
-
-    def __init__(self, response_code, messages):
-        """
-        :type response_code: int
-        :type messages: list[str]
-        """
-
-        super(ApiException, self).__init__(
-            self.generate_message_error(response_code, messages)
-        )
+class BunqError(Exception):
+    def __init__(self, message, response_code):
         self._response_code = response_code
+        self._message = message
 
-    def generate_message_error(self, response_code, messages):
-        """
-        :type response_code: int
-        :type messages: list[str]
+        super(BunqError, self).__init__(message)
 
-        :rtype: str
-        """
-
-        line_response_code = self._FORMAT_RESPONSE_CODE_LINE \
-            .format(response_code)
-
-        return self.glue_messages([line_response_code] + messages)
-
-    def glue_messages(self, messages):
-        """
-        :type messages: list[str]
-
-        :rtype: str
-        """
-
-        return self._GLUE_ERROR_MESSAGES.join(messages)
+    @property
+    def message(self):
+        return self._message
 
     @property
     def response_code(self):
-        """
-        :rtype: int
-        """
-
         return self._response_code
 
 
 class BunqException(Exception):
     def __init__(self, message):
         super(BunqException, self).__init__(message)
+
+
+class ApiException(BunqError):
+    pass
+
+
+class BadRequestException(BunqError):
+    pass
+
+
+class UnauthorizedException(BunqError):
+    pass
+
+
+class ForbiddenException(BunqError):
+    pass
+
+
+class NotFoundException(BunqError):
+    pass
+
+
+class MethodNotAllowedException(BunqError):
+    pass
+
+
+class ToManyRequestsException(BunqError):
+    pass
+
+
+class PleaseContactBunqException(BunqError):
+    pass
+

bunq/sdk/exception_hanlder.py

@@ -0,0 +1,68 @@
+from bunq.sdk.exception import BadRequestException
+from bunq.sdk.exception import UnauthorizedException
+from bunq.sdk.exception import ForbiddenException
+from bunq.sdk.exception import NotFoundException
+from bunq.sdk.exception import MethodNotAllowedException
+from bunq.sdk.exception import ToManyRequestsException
+from bunq.sdk.exception import PleaseContactBunqException
+from bunq.sdk.exception import ApiException
+
+
+class ExceptionHandler(Exception):
+    # Error response code constants
+    _HTTP_RESPONSE_CODE_BAD_REQUEST = 400
+    _HTTP_RESPONSE_CODE_UNAUTHORIZED = 401
+    _HTTP_RESPONSE_CODE_FORBIDDEN = 403
+    _HTTP_RESPONSE_CODE_NOT_FOUND = 404
+    _HTTP_RESPONSE_CODE_METHOD_NOT_ALLOWED = 405
+    _HTTP_RESPONSE_CODE_TOO_MANY_REQUESTS = 429
+    _HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR = 500
+
+    # Constants for formatting messages
+    _FORMAT_RESPONSE_CODE_LINE = 'HTTP Response Code: {}'
+    _GLUE_ERROR_MESSAGES = '\n'
+
+    @classmethod
+    def create_exception_for_response(cls, response_code, messages):
+        error_message = cls._generate_message_error(response_code, messages)
+
+        if response_code == cls._HTTP_RESPONSE_CODE_BAD_REQUEST:
+            return BadRequestException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_UNAUTHORIZED:
+            return UnauthorizedException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_FORBIDDEN:
+            return ForbiddenException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_NOT_FOUND:
+            return NotFoundException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_METHOD_NOT_ALLOWED:
+            return MethodNotAllowedException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_TOO_MANY_REQUESTS:
+            return ToManyRequestsException(error_message, response_code)
+        if response_code == cls._HTTP_RESPONSE_CODE_INTERNAL_SERVER_ERROR:
+            return PleaseContactBunqException(error_message, response_code)
+
+        return ApiException(error_message, response_code)
+
+    @classmethod
+    def _generate_message_error(cls, response_code, messages):
+        """
+        :type response_code: int
+        :type messages: list[str]
+
+        :rtype: str
+        """
+
+        line_response_code = cls._FORMAT_RESPONSE_CODE_LINE \
+            .format(response_code)
+
+        return cls._glue_messages([line_response_code] + messages)
+
+    @classmethod
+    def _glue_messages(cls, messages):
+        """
+        :type messages: list[str]
+
+        :rtype: str
+        """
+
+        return cls._GLUE_ERROR_MESSAGES.join(messages)