core logic

Author: Valian

django_application_logic/core.py

@@ -0,0 +1,56 @@
+import functools
+
+from django_application_logic.exceptions import ServiceException
+
+
+class PermissionResult(object):
+
+    def __init__(self, success, error=None):
+        self.success = success
+        self.error = error
+
+    @property
+    def errors(self):
+        return self.error.errors if self.error else None
+
+    @property
+    def error_code(self):
+        return self.error.error_code if self.error else None
+
+    def __nonzero__(self):
+        return self.success
+
+    def __eq__(self, other):
+        if isinstance(other, (bool, PermissionResult)):
+            return bool(self) == bool(other)
+        return False
+
+    def __repr__(self):
+        return u'<PermissionResult success={} error={}>'.format(self.success, self.error)
+
+
+def validator(validation_func):
+    def decorator(f):
+        @functools.wraps(f)
+        def wrapper(*args, **kwargs):
+            validate = kwargs.pop('validate', True)
+            if validate:
+                validation_func(raise_exception=True, *args, **kwargs)
+            return f(*args, **kwargs)
+        wrapper._validator = validation_func
+        return wrapper
+    return decorator
+
+
+def validation_func(f):
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs):
+        raise_exception = kwargs.pop('raise_exception', True)
+        try:
+            result = f(*args, **kwargs)
+            return PermissionResult(True if result is None else bool(result), None)
+        except ServiceException as e:
+            if raise_exception:
+                raise
+            return PermissionResult(False, e)
+    return wrapper

django_application_logic/errors.py

@@ -0,0 +1,33 @@
+from django_application_logic import exceptions
+from six import with_metaclass
+
+errors_registry = type('Errors', (), {})  # we setattr here all found errors
+
+
+class ErrorBase(object):
+    exception_class = None
+
+    def __init__(self, message):
+        self.message = message
+
+
+class NotPermitted(ErrorBase):
+    exception_class = exceptions.OperationNotPermittedException
+
+
+class InvalidOperation(ErrorBase):
+    exception_class = exceptions.InvalidOperationException
+
+
+class ServicesErrorsMetaclass(type):
+    def __init__(cls, name, bases, dict):
+        super(ServicesErrorsMetaclass, cls).__init__(name, bases, dict)
+        for attr_name, attr in dict.items():
+            if isinstance(attr, ErrorBase):
+                exception = attr.exception_class(attr.message, attr_name.lower(), cls)
+                setattr(errors_registry, attr_name, exception)
+                setattr(cls, attr_name, exception)
+
+
+class ServicesErrors(with_metaclass(ServicesErrorsMetaclass)):
+    pass

django_application_logic/exceptions.py

@@ -0,0 +1,13 @@
+class ServiceException(Exception):
+    def __init__(self, message=None, error_code=None, errors=None):
+        super(ServiceException, self).__init__(message)
+        self.errors = errors
+        self.error_code = error_code
+
+
+class InvalidOperationException(ServiceException):
+    pass
+
+
+class OperationNotPermittedException(ServiceException):
+    pass

django_application_logic/tests.py

@@ -0,0 +1,25 @@
+from django_application_logic.exceptions import InvalidOperationException, OperationNotPermittedException
+
+
+class shouldRaiseErrorCode(object):
+    def __init__(self, error):
+        self.error = error
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            raise AssertionError(u"Exception has not been raised")
+        desired_exceptions = (InvalidOperationException, OperationNotPermittedException)
+        if exc_type not in desired_exceptions:
+            raise AssertionError(u"Raised {} exception type where {} was expected.\nMore info:\n{}".format(
+                exc_type, desired_exceptions, exc_tb.format_exc()))
+        if exc_val != self.error:
+            raise AssertionError(u'Expected error code "{}", but received "{}"'.format(self.error, exc_val))
+        return True
+
+
+class ApplicationLogicTestMixin(object):
+
+    shouldRaiseErrorCode = shouldRaiseErrorCode