entirius-django-utils 2.0.0__py3-none-any.whl

django_utils/admin/__init__.py

@@ -0,0 +1,23 @@
+from django_utils.settings import ADMIN_THEME
+
+if ADMIN_THEME == "unfold":
+    from django.contrib import admin
+    from django.contrib.auth.admin import GroupAdmin as BaseGroupAdmin
+    from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+    from django.contrib.auth.models import Group, User
+    from unfold.admin import ModelAdmin
+    from unfold.forms import AdminPasswordChangeForm, UserChangeForm, UserCreationForm
+
+    admin.site.unregister(User)
+    admin.site.unregister(Group)
+
+    @admin.register(User)
+    class UserAdmin(BaseUserAdmin, ModelAdmin):
+        # Forms loaded from `unfold.forms`
+        form = UserChangeForm
+        add_form = UserCreationForm
+        change_password_form = AdminPasswordChangeForm
+
+    @admin.register(Group)
+    class GroupAdmin(BaseGroupAdmin, ModelAdmin):
+        pass

django_utils/admin/base_admin.py

@@ -0,0 +1,31 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import logging
+
+from django_utils.settings import ADMIN_THEME
+
+logger = logging.getLogger(__name__)
+
+match ADMIN_THEME:
+    case "unfold":
+        try:
+            from unfold.admin import ModelAdmin, StackedInline, TabularInline
+        except ImportError:
+            logger.error("Unfold admin theme is not installed, run: pip install django-unfold")
+            from django.contrib.admin import ModelAdmin, StackedInline, TabularInline
+    case _:
+        from django.contrib.admin import ModelAdmin, StackedInline, TabularInline
+
+
+class BaseModelAdmin(ModelAdmin):
+    pass
+
+
+class BaseStackedInline(StackedInline):
+    pass
+
+
+class BaseTabularInline(TabularInline):
+    pass

django_utils/api/base_response.py

@@ -0,0 +1,47 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+
+from .errors import ErrorInfo
+
+
+class BaseResponse:
+    errors = None
+
+    def __init__(self, errors: list[ErrorInfo] = None):
+        self.errors = errors
+
+        if errors is None:
+            self.errors = []
+
+    def add_error(
+        self,
+        message: str,
+        code: str,
+        affected_values: list[str] | None = None,
+        affected_field: str | None = None,
+        extra: dict | None = None,
+    ):
+        if code in [error.code for error in self.errors]:
+            for error in self.errors:
+                if error.code == code:
+                    if affected_values:
+                        error.affected_values = list(set(error.affected_values + affected_values))
+                    break
+        else:
+            self.errors.append(ErrorInfo(message, code, affected_values, affected_field, extra))
+        return self
+
+    def add_errors(self, errors: list[ErrorInfo | dict]):
+        for error in errors:
+            if isinstance(error, ErrorInfo):
+                self.add_error(error.message, error.code, error.affected_values, error.affected_field, error.extra)
+            elif isinstance(error, dict):
+                message = error.get("message", None)
+                code = error.get("code", None)
+                if isinstance(message, str) and isinstance(code, str):
+                    self.add_error(message, code, error.get("affected_values", None))
+            else:
+                continue
+        return self

django_utils/api/decorators.py

@@ -0,0 +1,189 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import ipaddress
+import logging
+from functools import partial, wraps
+
+from django.contrib import auth
+from django.core.exceptions import ObjectDoesNotExist
+from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
+from django_regional.models import Country
+from webargs.djangoparser import use_args
+
+from django_utils import settings
+from django_utils.api.exceptions import JWTException
+
+from .exceptions import MethodNotAllowed, Unauthorized, handle_exception
+from .responses import PaginatedResponse, Response, to_json_response
+
+logger = logging.getLogger(__name__)
+
+
+def api_view(view):
+    """
+    Wraps view function or method on a class based view,
+    enforcing standard response formatting and exception handling.
+
+    Decorated function must return a Response object.
+    Response class can be found in helpers/response.py
+    """
+
+    @wraps(view)
+    def _wrapped(request, *args, **kwargs):
+        try:
+            response = view(request, *args, **kwargs)
+        except Exception as e:
+            response = handle_exception(e, request)
+        finally:
+            if isinstance(response, (Response, PaginatedResponse)):
+                return to_json_response(response)
+            elif isinstance(response, HttpResponseRedirect):
+                return response
+            elif isinstance(response, HttpResponse):
+                return response
+            else:
+                JsonResponse({"error": "view returned unsupported response type"})
+
+    return _wrapped
+
+
+def authenticate_optional(view):
+    @wraps(view)
+    def _wrapped(request, *args, **kwargs):
+        try:
+            request.user = auth.authenticate(request)
+        except JWTException:
+            request.user = None
+            pass
+
+        response = view(request, *args, **kwargs)
+        return response
+
+    return _wrapped
+
+
+def authenticate(view):
+    @wraps(view)
+    def _wrapped(request, *args, **kwargs):
+        request.user = auth.authenticate(request)
+        request.customer = request.user.customer if request.user is not None else None
+        response = view(request, *args, **kwargs)
+        return response
+
+    return _wrapped
+
+
+def require_authentication(view):
+    @wraps(view)
+    def _wrapped(request, *args, **kwargs):
+        user = request.user
+        passed = user is not None and user.is_authenticated
+        if passed:
+            result = view(request, *args, **kwargs)
+            return result
+        else:
+            raise Unauthorized
+
+    return _wrapped
+
+
+def require_http_method(*methods):
+    def _wrapper(view):
+        @wraps(view)
+        def _wrapped(request, *args, **kwargs):
+            passed = request.method in methods
+            if passed:
+                result = view(request, *args, **kwargs)
+                return result
+            else:
+                raise MethodNotAllowed
+
+        return _wrapped
+
+    return _wrapper
+
+
+def ip_getter(view_func):
+    """
+    Dekorator, który pobiera adres IP z nagłówka i zapisuje go do request.ip.
+    Domyślnie sprawdza nagłówek X-Forwarded-For, a następnie X-Real-IP.
+    Jeśli nie ma tych nagłówków, używa request.META.get('REMOTE_ADDR').
+    """
+
+    @wraps(view_func)
+    def _wrapped_view(request, *args, **kwargs):
+        # Próba pobrania IP z różnych nagłówków HTTP
+        if (last_session_ip := request.headers.get(settings.HEADER_IP_ADDRESS, None)) is not None:
+            try:
+                ipaddress.ip_address(last_session_ip)
+                request.last_session_ip = last_session_ip
+            except ValueError:
+                logger.warning(f"IP address {last_session_ip} is not valid")
+
+        response = view_func(request, *args, **kwargs)
+        return response
+
+    return _wrapped_view
+
+
+def save_ip_and_country(view_func):
+    """
+
+    request needs to have headers with keys:
+    - settings.HEADER_IP_ADDRESS
+    - settings.HEADER_COUNTRY
+
+    and customer object in request.customer
+
+    """
+
+    @wraps(view_func)
+    def _wrapped_view(request, *args, **kwargs):
+        response = view_func(request, *args, **kwargs)
+
+        customer = request.customer
+        if not customer:
+            return response
+
+        if (last_session_ip := request.headers.get(settings.HEADER_IP_ADDRESS, None)) is not None:
+            try:
+                ipaddress.ip_address(last_session_ip)
+                customer.last_session_ip = last_session_ip
+            except ValueError:
+                logger.warning(f"IP address {last_session_ip} for customer {customer.uid} is not valid")
+
+        if (last_session_country := request.headers.get(settings.HEADER_COUNTRY, None)) is not None:
+            try:
+                country = Country.objects.get(iso2=last_session_country)
+                customer.last_session_country = country
+            except ObjectDoesNotExist:
+                logger.warning(f"Country {last_session_country} for customer {customer.uid} is not valid")
+        try:
+            customer.save()
+        except Exception as e:
+            logger.error(f"Failed to save customer {customer.uid} last session data: {e}")
+        return response
+
+    return _wrapped_view
+
+
+def verify_captcha(view_func):
+    try:
+        from django_captcha.output.decorators import verify_recaptcha
+    except ImportError:
+        return view_func
+
+    return verify_recaptcha(view_func)
+
+
+# Uses webargs django parser
+# BASICS https://webargs.readthedocs.io/en/latest/quickstart.html#basic-usage
+# MODULE API https://webargs.readthedocs.io/en/latest/api.html#module-webargs.djangoparser
+# HOW TO USE WHAT'S BELOW https://webargs.readthedocs.io/en/latest/advanced.html#mixing-locations
+# HOW TO USE WITH DATACLASSES https://github.com/lovasoa/marshmallow_dataclass
+# TODO Think about autodocs with apispec and apispec-decorator-crawler
+parse_body = partial(use_args, location="json")
+parse_form = partial(use_args, location="form")
+parse_parameters = partial(use_args, location="query")

django_utils/api/errors.py

@@ -0,0 +1,24 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ErrorInfo:
+    message: str
+    code: str
+    affected_values: list[str] | None = None
+    affected_field: str | None = None
+    extra: dict | None = None
+
+    def to_dict(self):
+        result = {"message": self.message, "code": self.code}
+        if self.affected_values:
+            result["affected_values"] = self.affected_values
+        if self.affected_field:
+            result["affected_field"] = self.affected_field
+        if self.extra:
+            result["extra"] = self.extra
+        return result

django_utils/api/exceptions.py

@@ -0,0 +1,132 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import logging
+
+from django.http import HttpRequest
+from marshmallow.exceptions import MarshmallowError
+from marshmallow.exceptions import ValidationError as MarshmallowValidationError
+
+from ..settings import LOG_HTTP_CODE_GTE
+from .base_response import BaseResponse
+from .errors import ErrorInfo
+from .responses import Response
+
+logger = logging.getLogger(__name__)
+
+
+class APIException(BaseResponse, Exception):
+    data: dict = {}
+    message: str = "Error"
+    status: str = "ERR"
+    status_code: int = 500
+
+    def __init__(self, data=None, message=None, status=None, errors: list[ErrorInfo] = None) -> None:
+        if errors is None:
+            errors = []
+        super().__init__(errors)
+        self.data = self.data if data is None else data
+        self.message = self.message if message is None else message
+        self.status = self.status if status is None else status
+
+    def __str__(self) -> str:
+        return f"{self.status}: {self.message}"
+
+
+class BadRequest(APIException):
+    message = "Invalid request"
+    status = "BAD_REQUEST"
+    status_code = 400
+
+
+class EmailTaken(BadRequest):
+    message = "Email already in use"
+    status = "EMAIL_TAKEN"
+
+
+class ValidationError(BadRequest):
+    message = "Validation Error"
+
+
+class Unauthorized(APIException):
+    message = "Requires authentication"
+    status = "UNAUTHORIZED"
+    status_code = 401
+
+
+class JWTException(Unauthorized):
+    def __init__(self, message, status, code):
+        self.message = message
+        self.status = status
+        self.code = code
+
+
+class Forbidden(APIException):
+    message = "Permission denied"
+    status = "FORBIDDEN"
+    status_code = 403
+
+
+class NotFound(APIException):
+    message = "Resource not found"
+    status = "NOT_FOUND"
+    status_code = 404
+
+
+class MethodNotAllowed(APIException):
+    message = "Invalid http method"
+    status = "METHOD_NOT_ALLOWED"
+    status_code = 405
+
+
+def handle_django_exception(e): ...
+
+
+def handle_marshmallow_exception(e):
+    def normalize(e):
+        if isinstance(e, MarshmallowValidationError):
+            return normalize(e.normalized_messages())
+        elif isinstance(e, dict):
+            return {key: normalize(elem) for key, elem in e.items()}
+        elif isinstance(e, list):
+            return [normalize(elem) for elem in e]
+        else:
+            return e
+
+    if isinstance(e, MarshmallowValidationError):
+        status = "BAD_REQUEST"
+        status_code = 400
+        message = "Validation error"
+        data = normalize(e)
+    else:
+        status = "ERR"
+        status_code = 500
+        message = "Unhandeld Validaion Exception"
+        data = {}
+
+    return status, status_code, message, data
+
+
+def handle_exception(e: Exception, request: HttpRequest):
+    if isinstance(e, APIException):
+        status = e.status
+        status_code = e.status_code
+        message = e.message
+        data = e.data
+        errors = e.errors
+    elif isinstance(e, MarshmallowError):
+        errors = []
+        status, status_code, message, data = handle_marshmallow_exception(e)
+    else:
+        errors = []
+        status = "ERR"
+        status_code = 500
+        message = "Internal Exception"
+        data = {}
+
+    if status_code >= LOG_HTTP_CODE_GTE:
+        # logger.exception is better for sentry than logger.error
+        logger.exception(e)
+
+    return Response(status=status, status_code=status_code, message=message, data=data, errors=errors)

django_utils/api/filter.py

@@ -0,0 +1,20 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from typing import Any
+
+from django.db.models import QuerySet
+from django_filters.filterset import FilterSetMetaclass
+
+
+def filter_qs(filterset: FilterSetMetaclass, params: dict, queryset: QuerySet, request=None) -> tuple[QuerySet, Any]:
+    """
+    Filters queryset according to request params
+
+    Ex:
+    qs = Model.objects.all()
+    filtered_qs = filter_queryset(ModelFilter, request.GET, qs)
+    """
+    filter_obj = filterset(params, request=request, queryset=queryset)
+    return filter_obj.qs, filter_obj

django_utils/api/pagination.py

@@ -0,0 +1,37 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+
+from django.core.paginator import Paginator
+from django.db.models import QuerySet
+
+from .exceptions import BadRequest
+
+
+def paginate_qs(params: dict, objs_list: QuerySet) -> tuple[dict, QuerySet]:
+    """
+    Paginates list or queryset according to request params
+
+    Ex:
+    qs = Model.objects.all()
+    pagination, paginated_qs = paginate(request.GET, qs)
+    """
+    page_param = params.get("page", None)
+    which_page = int(page_param) if page_param is not None else 1
+    limit_param = params.get("limit", None)
+    objs_per_page = int(limit_param) if limit_param is not None else 10
+    if objs_per_page > 100:
+        raise BadRequest(message="Requesting more than 100 records per request is not allowed")
+    else:
+        paginator = Paginator(objs_list, objs_per_page)
+        pages = paginator.num_pages
+        records = paginator.count
+        pagination_dict = {
+            "page": which_page,
+            "limit": objs_per_page,
+            "pages": pages,
+            "records": records,
+        }
+        page = paginator.page(which_page)
+        return pagination_dict, page.object_list

django_utils/api/responses.py

@@ -0,0 +1,80 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from typing import Any
+
+from django.http import JsonResponse
+
+from .base_response import BaseResponse
+from .errors import ErrorInfo
+
+
+class Response(BaseResponse):
+    language = None
+    currency = None
+    country = None
+
+    def __init__(
+        self,
+        data: Any,
+        status: str = "OK",
+        message: str = "",
+        status_code: int = 200,
+        messages: list[str] | None = None,
+        errors: list[ErrorInfo] = None,
+    ):
+        super().__init__(errors)
+        self.data = data
+        self.status = status
+        self.message = message
+        self.status_code = status_code
+
+        if messages is None:
+            messages = []
+
+        self.messages = messages
+        if message == "" and len(messages) > 0:
+            self.message = messages[0]
+
+    def add_regional(self, language: str | None = None, currency: str | None = None, country: str | None = None):
+        self.language = language
+        self.currency = currency
+        self.country = country
+        return self
+
+
+class PaginatedResponse(Response):
+    def __init__(
+        self,
+        pagination: dict,
+        data: list,
+        status: str = "OK",
+        message: str = "",
+        status_code: int = 200,
+        messages: list[str] | None = None,
+    ):
+        super().__init__(data, status, message, status_code, messages)
+        self.pagination = pagination
+
+
+def to_json_response(res: Response):
+    base = {
+        "meta": {
+            "status": res.status,
+            "message": res.message,
+            "messages": res.messages,
+            "errors": [error.to_dict() for error in res.errors],
+            "regional": {"language": res.language, "currency": res.currency, "country": res.country},
+        },
+        "data": res.data,
+    }
+
+    if isinstance(res, PaginatedResponse):
+        body = dict(**base, pagination=res.pagination)
+    else:
+        body = base
+
+    response = JsonResponse(body)
+    response.status_code = res.status_code
+    return response

django_utils/api/utils.py

@@ -0,0 +1,15 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+
+from django_utils import settings
+
+
+# Need to have it here, otherwise django will iterate over a queryset
+def make_media_url(media_path: str) -> str | None:
+    media_url = getattr(settings, "MEDIA_URL", "")
+    if media_path is not None:
+        return "".join([media_url, media_path])
+    else:
+        return None