Fix validation error and update exceptions

Author: francescozoccheddu

dsjapi/decorator.py

@@ -5,6 +5,7 @@
 from . import exceptions
 from . import fields
 
+
 def api(field=None):
 
  def decorator(func):
@@ -24,7 +25,7 @@ def wrappedFunc(request):
  try:
  requestData = json.loads(request.body)
  except ValueError as e:
- raise exceptions.BadRequestException("Error while parsing JSON content", {"error": str(e)})
+ raise exceptions.BadRequestException("Error while parsing JSON content: {}".format(str(e)))
 
  if field is not None:
  if not isinstance(field, fields.Field):
@@ -36,7 +37,7 @@ def add(v):
  cleanedData = v
  field.cleanAndAdd(requestData is not None, requestData, add)
  except fields.FieldException as e:
- raise exceptions.BadRequestException("Field exception: {}".format(e.getMessage()))
+ raise exceptions.BadRequestException("Field exception", e)
  else:
  cleanedData = requestData
 
@@ -55,5 +56,3 @@ def add(v):
  return wrappedFunc
 
  return decorator
-
-

dsjapi/exceptions.py

@@ -1,63 +1,108 @@
 from django.http import JsonResponse, HttpResponseNotAllowed
 
-class ServerException(Exception):
+
+class PrintableException(Exception):
+
+ def toDict(self):
+ return {"type": self.__class__.__name__}
+
+ def __str__(self):
+ return self.__class__.__name__
+
+ def __repr__(self):
+ return repr(self.toDict())
+
+
+class ServerException(PrintableException):
 
  def buildResponse(self):
  raise NotImplementedError()
 
+
 class JSONServerException(ServerException):
 
- def __init__(self, status, message=None, data=None):
+ def __init__(self, status):
  self._status = status
- self._message = message
- self._data = data
-
- def getData(self):
- return self._data
 
  def getStatus(self):
  return self._status
 
+ def buildResponse(self):
+ return JsonResponse(self.toDict(), status=self._status)
+
+
+class CommonException(PrintableException):
+
+ def __init__(self, message=None, cause=None):
+ self._message = message
+ self._cause = cause
+
+ def getCause(self):
+ return self._cause
+
  def getMessage(self):
  return self._message
 
- def buildResponse(self):
- content = {}
+ def toDict(self):
+ content = super().toDict()
  if self._message is not None:
  content["message"] = self._message
- if self._data is not None:
- content["data"] = self._data
- return JsonResponse(content, status=self._status)
+ if self._cause is not None:
+ content["cause"] = self._cause.toDict()
+ return content
+
+ def __str__(self):
+ txt = self.__class__.__name__
+ if self._message is not None:
+ txt += ": {}".format(self._message)
+ if self._cause is not None:
+ txt += "\nCaused by:\n{}".format(str(self._cause))
+ return txt
+
+
+class CommonJSONServerException(JSONServerException, CommonException):
 
+ def __init__(self, status, message=None, cause=None):
+ JSONServerException.__init__(self, status)
+ CommonException.__init__(self, message, cause)
 
-class AuthenticationException(JSONServerException):
 
- def __init__(self, message=None, data=None):
- super().__init__(401, message, data)
+class AuthenticationException(CommonJSONServerException):
 
+ def __init__(self, message=None, cause=None):
+ super().__init__(401, message, cause)
 
-class BadRequestException(JSONServerException):
 
- def __init__(self, message=None, data=None):
- super().__init__(400, message, data)
+class BadRequestException(CommonJSONServerException):
 
+ def __init__(self, message=None, cause=None):
+ super().__init__(400, message, cause)
 
-class NotFoundException(JSONServerException):
 
- def __init__(self, message=None, data=None):
- super().__init__(404, message, data)
+class NotFoundException(CommonJSONServerException):
 
+ def __init__(self, message=None, cause=None):
+ super().__init__(404, message, cause)
 
-class ServerErrorException(JSONServerException):
 
- def __init__(self, message=None, data=None):
- super().__init__(500, message, data)
+class ServerErrorException(CommonJSONServerException):
+
+ def __init__(self, message=None, cause=None):
+ super().__init__(500, message, cause)
 
 
 class MethodNotAllowedException(ServerException):
 
  def __init__(self, allowedMethods):
  self._allowedMethods = allowedMethods
 
+ def toDict(self):
+ content = super().toDict()
+ content["allowedMethods"] = self._allowedMethods
+ return content
+
+ def __str__(self):
+ return "{}\nAllowed methods:\n{}".format(self.__class__.__name__, self._allowedMethods)
+
  def buildResponse(self):
  return HttpResponseNotAllowed(self._allowedMethods)

dsjapi/fields.py

@@ -1,14 +1,13 @@
 from enum import Enum, auto
 import dateutil
 import re
+from . import exceptions
 
-class FieldException(Exception):
 
- def __init__(self, message):
- self._message = message
+class FieldException(exceptions.CommonException):
 
- def getMessage(self):
- return self._message
+ def __init__(self, message, cause=None):
+ super().__init__(message, cause)
 
 
 class Field:
@@ -62,9 +61,18 @@ def __init__(self, type, missing=Field.Do.RAISE, error=Field.Do.RAISE, default=N
  def getType(self):
  return self._type
 
+ @staticmethod
+ def formatTypeConstraint(typeConstraint):
+ if isinstance(typeConstraint, type):
+ return typeConstraint.__name__
+ elif isinstance(typeConstraint, (tuple, list)):
+ return " or ".join(map(lambda t: t.__name__, typeConstraint))
+ else:
+ return "<error type>"
+
  def clean(self, value):
  if not isinstance(value, self._type):
- raise FieldException("Expected type {}".format(self._type))
+ raise FieldException("Expected type {}".format(TypeField.formatTypeConstraint(self._type)))
  return value
 
 
@@ -163,7 +171,7 @@ def clean(self, value):
  if isinstance(self._fields, list):
  fields = self._fields
  elif isinstance(self._fields, Field):
- fields = [None] * len(value)
+ fields = [self._fields] * len(value)
  else:
  raise TypeError("Bad type fields type")
  items = []
@@ -172,7 +180,7 @@ def clean(self, value):
  try:
  fields[i].cleanAndAdd(True, item, items.append)
  except FieldException as e:
- raise FieldException("Field exception on item {}: {}".format(i, e.getMessage()))
+ raise FieldException("Field exception on item {}".format(i), e)
  else:
  items.append(item)
  value = items
@@ -234,7 +242,7 @@ def add(v):
  dictionary[key] = v
  self._fields.cleanAndAdd(True, item, add)
  except FieldException as e:
- raise FieldException('Field exception on item "{}": {}'.format(key, e.getMessage()))
+ raise FieldException('Field exception on item "{}"'.format(key), e)
  elif isinstance(self._fields, dict):
  for key, item in self._fields.items():
  try:
@@ -243,7 +251,7 @@ def add(v):
  present = key in value
  self._fields[key].cleanAndAdd(present, value[key] if present else None, add)
  except FieldException as e:
- raise FieldException('Field exception on item "{}": {}'.format(key, e.getMessage()))
+ raise FieldException('Field exception on item "{}"'.format(key), e)
  unexpected = set(value.keys()) - set(self._fields.keys())
  if len(unexpected) > 0:
  raise FieldException('Unexpected fields {}'.format(unexpected))

setup.py

@@ -9,7 +9,7 @@
 setup(
  name='django-simple-json-api',
  author='Francesco Zoccheddu',
- version='0.0.1',
+ version='0.0.2',
  description='Create simple JSON APIs with Django',
  long_description=_README,
  long_description_content_type='text/markdown',