django-content-studio 1.0.0b5__py3-none-any.whl

content_studio/__init__.py

@@ -0,0 +1,7 @@
+__title__ = "Django Content Studio"
+__version__ = "1.0.0-beta.5"
+__author__ = "Leon van der Grient"
+__license__ = "MIT"
+
+# Version synonym
+VERSION = __version__

content_studio/admin.py

@@ -0,0 +1,307 @@
+import uuid
+from typing import Type
+
+from django.contrib import admin
+from django.db import models
+from django.db.models import Model
+from rest_framework.request import HttpRequest
+
+from . import widgets, formats
+from .form import FormSet, FormSetGroup, Field, Component
+from .login_backends import LoginBackendManager
+from .token_backends import TokenBackendManager
+from .utils import get_related_field_name, flatten
+
+register = admin.register
+
+
+class StackedInline(admin.StackedInline):
+    pass
+
+
+class TabularInline(admin.TabularInline):
+    pass
+
+
+class AdminSite(admin.AdminSite):
+    """
+    Enhanced admin site for Django Content Studio.
+    """
+
+    token_backend = TokenBackendManager()
+
+    login_backend = LoginBackendManager()
+
+    dashboard = None
+
+    model_groups = None
+
+    default_widget_mapping = {
+        models.CharField: widgets.InputWidget,
+        models.IntegerField: widgets.InputWidget,
+        models.SmallIntegerField: widgets.InputWidget,
+        models.BigIntegerField: widgets.InputWidget,
+        models.PositiveIntegerField: widgets.InputWidget,
+        models.PositiveSmallIntegerField: widgets.InputWidget,
+        models.PositiveBigIntegerField: widgets.InputWidget,
+        models.FloatField: widgets.InputWidget,
+        models.DecimalField: widgets.InputWidget,
+        models.SlugField: widgets.SlugWidget,
+        models.TextField: widgets.TextAreaWidget,
+        models.BooleanField: widgets.CheckboxWidget,
+        models.NullBooleanField: widgets.CheckboxWidget,
+        models.ForeignKey: widgets.ForeignKeyWidget,
+        models.ManyToManyField: widgets.ManyToManyWidget,
+        models.OneToOneField: widgets.ForeignKeyWidget,
+        models.DateField: widgets.DateWidget,
+        models.DateTimeField: widgets.DateTimeWidget,
+        models.TimeField: widgets.TimeWidget,
+        models.JSONField: widgets.JSONWidget,
+        # Common third-party fields
+        "AutoSlugField": widgets.SlugWidget,
+    }
+
+    default_format_mapping = {
+        models.CharField: formats.TextFormat,
+        models.IntegerField: formats.NumberFormat,
+        models.SmallIntegerField: formats.NumberFormat,
+        models.BigIntegerField: formats.NumberFormat,
+        models.PositiveIntegerField: formats.NumberFormat,
+        models.PositiveSmallIntegerField: formats.NumberFormat,
+        models.PositiveBigIntegerField: formats.NumberFormat,
+        models.FloatField: formats.NumberFormat,
+        models.DecimalField: formats.NumberFormat,
+        models.SlugField: formats.TextFormat,
+        models.TextField: formats.TextFormat,
+        models.BooleanField: formats.BooleanFormat,
+        models.NullBooleanField: formats.BooleanFormat,
+        models.DateField: formats.DateFormat,
+        models.DateTimeField: formats.DateTimeFormat,
+        models.TimeField: formats.TimeFormat,
+        models.ForeignKey: formats.ForeignKeyFormat,
+        models.OneToOneField: formats.ForeignKeyFormat,
+        models.JSONField: formats.JSONFormat,
+    }
+
+    def setup(self):
+        # Add token backend's view set to the
+        # Content Studio router.
+        self.token_backend.set_up_router()
+        # Add login backend's view set to the
+        # Content Studio router.
+        self.login_backend.set_up_router()
+        # Add dashboard's view set to the
+        # Content Studio router.
+        if self.dashboard:
+            self.dashboard.set_up_router()
+
+    def get_thumbnail(self, obj) -> str:
+        """
+        Method for getting and manipulating the image path (or URL).
+        By default, this returns the image path as is.
+        """
+        return obj.file.url
+
+
+admin_site = AdminSite()
+
+
+class ModelAdmin(admin.ModelAdmin):
+    """
+    Enhanced model admin for Django Content Studio and integration with
+    Django Content Framework. Although it's relatively backwards compatible,
+    some default behavior has been changed.
+    """
+
+    # Whether the model is a singleton and should not show
+    # the list view.
+    is_singleton = False
+
+    # Override the widget used for certain fields by adding
+    # a map of field to widget. Fields that are not included
+    # will fall back to their default widget.
+    #
+    # @example
+    # widget_mapping = {'is_published': widgets.SwitchWidget}
+    widget_mapping = None
+
+    # Override the format used for certain fields by adding
+    # a map of field to format. Fields that are not included
+    # will fall back to their default format.
+    #
+    # @example
+    # format_mapping = {'file_size': widgets.FileSizeWidget}
+    format_mapping = None
+
+    # We set a lower limit than Django's default of 100
+    list_per_page = 20
+
+    # Description shown below model name on list pages
+    list_description = ""
+
+    # Configure the main section in the edit-view.
+    edit_main: list[type[FormSetGroup | FormSet | Field | str]] = []
+
+    # Configure the sidebar in the edit-view.
+    edit_sidebar: list[type[FormSet | Field | str]] = []
+
+    icon = None
+
+    def has_add_permission(self, request):
+        is_singleton = getattr(self.model, "is_singleton", False)
+
+        # Don't allow to add more than one singleton object.
+        if is_singleton and self.model.objects.get():
+            return False
+
+        return super().has_add_permission(request)
+
+    def has_delete_permission(self, request, obj=None):
+        is_singleton = getattr(self.model, "is_singleton", False)
+
+        if is_singleton:
+            return False
+
+        return super().has_delete_permission(request, obj)
+
+    def get_component(self, component_id: uuid.UUID):
+        """
+        Retrieves a component from the edit_main or edit_sidebar attributes by ID.
+        :param component_id:
+        :return:
+        """
+        all_fields = getattr(self, "edit_main", []) + getattr(self, "edit_sidebar", [])
+
+        flat_fields = flatten(
+            [f.get_fields() if hasattr(f, "get_fields") else [f] for f in all_fields]
+        )
+
+        components = [c for c in flat_fields if issubclass(c.__class__, Component)]
+
+        for component in components:
+            if component.component_id == component_id:
+                return component
+
+        return None
+
+
+class AdminSerializer:
+    """
+    Class for serializing Django admin classes.
+    """
+
+    def __init__(self, admin_class: ModelAdmin):
+        self.admin_class = admin_class
+
+    def serialize(self, request: HttpRequest):
+        admin_class = self.admin_class
+        format_mapping = getattr(admin_class, "format_mapping", None) or {}
+        widget_mapping = getattr(admin_class, "widget_mapping", None) or {}
+
+        return {
+            "icon": getattr(admin_class, "icon", None),
+            "is_singleton": getattr(admin_class, "is_singleton", False),
+            "edit": {
+                "main": self.serialize_edit_main(request),
+                "sidebar": self.serialize_edit_sidebar(request),
+                "inlines": [
+                    {
+                        "model": inline.model._meta.label_lower,
+                        "fk_name": get_related_field_name(inline, admin_class.model),
+                        "list_display": getattr(inline, "list_display", None)
+                        or ["__str__"],
+                    }
+                    for inline in admin_class.inlines
+                ],
+            },
+            "list": {
+                "per_page": admin_class.list_per_page,
+                "description": getattr(admin_class, "list_description", ""),
+                "display": admin_class.list_display,
+                "search": len(admin_class.search_fields) > 0,
+                "filter": admin_class.list_filter,
+                "sortable_by": admin_class.sortable_by,
+            },
+            "widget_mapping": {
+                field: widget.serialize() for field, widget in widget_mapping.items()
+            },
+            "format_mapping": {
+                field: format.serialize() for field, format in format_mapping.items()
+            },
+            "permissions": {
+                "add_permission": admin_class.has_add_permission(request),
+                "delete_permission": admin_class.has_delete_permission(request),
+                "change_permission": admin_class.has_change_permission(request),
+                "view_permission": admin_class.has_view_permission(request),
+            },
+        }
+
+    def serialize_edit_main(self, request):
+        admin_class = self.admin_class
+
+        return [
+            i.serialize()
+            for i in self.get_edit_main(
+                getattr(admin_class, "edit_main", admin_class.get_fields(request))
+            )
+        ]
+
+    def serialize_edit_sidebar(self, request):
+        admin_class = self.admin_class
+
+        return [
+            i.serialize()
+            for i in self.get_edit_sidebar(getattr(admin_class, "edit_sidebar", None))
+        ]
+
+    def get_edit_main(self, edit_main):
+        """
+        Returns a normalized list of form set groups.
+
+        Form sets will be wrapped in a form set group. If the edit_main attribute is a list of fields,
+        they are wrapped in a form set and a form set group.
+        """
+        if not edit_main:
+            return []
+        if isinstance(edit_main[0], FormSetGroup):
+            return edit_main
+        if isinstance(edit_main[0], FormSet):
+            return [FormSetGroup(formsets=edit_main)]
+
+        return [FormSetGroup(formsets=[FormSet(fields=edit_main)])]
+
+    def get_edit_sidebar(self, edit_sidebar):
+        """
+        Returns a normalized list of form sets for the edit_sidebar.
+
+        If the edit_sidebar attribute is a list of fields,
+        they are wrapped in a form set.
+        """
+        if not edit_sidebar:
+            return []
+        if isinstance(edit_sidebar[0], FormSet):
+            return edit_sidebar
+
+        return [FormSet(fields=edit_sidebar)]
+
+
+class ModelGroup:
+    name = None
+    label = None
+    icon = None
+    color = None
+    models = None
+
+    def __init__(
+        self,
+        name: str,
+        label: str = None,
+        icon: str = None,
+        color: str = None,
+        models: list[Type[Model]] = None,
+    ):
+        self.name = name
+        self.label = label or name.capitalize()
+        self.icon = icon
+        self.color = color
+        self.models = models or []

content_studio/apps.py

@@ -0,0 +1,100 @@
+from django.apps import AppConfig
+from django.contrib import admin
+
+from . import VERSION
+from .paginators import ContentPagination
+from .settings import cs_settings
+from .utils import is_runserver
+
+
+class DjangoContentStudioConfig(AppConfig):
+    name = "content_studio"
+    label = "content_studio"
+    initialized = False
+
+    def ready(self):
+        from .utils import log
+
+        if is_runserver() and not self.initialized:
+            self.initialized = True
+
+            log("\n")
+            log("----------------------------------------")
+            log("Django Content Studio")
+            log(f"Version {VERSION}")
+            log("----------------------------------------")
+            log(":rocket:", "Starting Django Content Studio")
+            log(":mag:", "Discovering admin models...")
+            registered_models = len(admin.site._registry)
+            log(
+                ":white_check_mark:",
+                f"[green]Found {registered_models} admin models[/green]",
+            )
+            # Set up admin site routes
+            admin_site = cs_settings.ADMIN_SITE
+            admin_site.setup()
+
+            # Set up content CRUD APIs
+            self._create_crud_api()
+
+            log("\n")
+
+    def _create_crud_api(self):
+        from .utils import log
+
+        for model, admin_model in admin.site._registry.items():
+            self._create_view_set(model, admin_model)
+
+            for inline in admin_model.inlines:
+                self._create_view_set(
+                    parent=model, model=inline.model, admin_model=inline
+                )
+
+        log(
+            ":white_check_mark:",
+            f"[green]Created CRUD API[/green]",
+        )
+
+    def _create_view_set(self, model, admin_model, parent=None):
+        from .viewsets import BaseModelViewSet
+        from .router import content_studio_router
+        from .serializers import ContentSerializer
+
+        class Pagination(ContentPagination):
+            page_size = getattr(admin_model, "list_per_page", 10)
+
+        class ViewSet(BaseModelViewSet):
+            _model = model
+            _admin_model = admin_model
+            is_singleton = getattr(admin_model, "is_singleton", False)
+            pagination_class = Pagination
+            queryset = _model.objects.all()
+            search_fields = list(getattr(_admin_model, "search_fields", []))
+
+            def get_serializer_class(self):
+                # For list views we include the specified list_display fields.
+                if self.action == "list" and not self.is_singleton:
+                    available_fields = [
+                        "id",
+                        "__str__",
+                    ] + list(getattr(self._admin_model, "list_display", []))
+                # In all other cases we include all fields.
+                else:
+                    available_fields = "__all__"
+
+                class Serializer(ContentSerializer):
+
+                    class Meta:
+                        model = self._model
+                        fields = available_fields
+
+                return Serializer
+
+        if parent:
+            prefix = f"api/inlines/{parent._meta.label_lower}/{model._meta.label_lower}"
+            basename = f"content_studio_api-{parent._meta.label_lower}-{model._meta.label_lower}"
+        else:
+            prefix = f"api/content/{model._meta.label_lower}"
+            basename = f"content_studio_api-{model._meta.label_lower}"
+
+        content_studio_router.register(prefix, ViewSet, basename)

content_studio/dashboard/__init__.py

@@ -0,0 +1,64 @@
+from rest_framework.decorators import action
+from rest_framework.exceptions import NotFound
+from rest_framework.parsers import JSONParser
+from rest_framework.renderers import JSONRenderer
+from rest_framework.response import Response
+from rest_framework.viewsets import ViewSet
+
+from content_studio.settings import cs_settings
+
+
+class Dashboard:
+    """
+    The Dashboard class is used to define the structure of the dashboard
+    in Django Content Studio.
+    """
+
+    widgets = None
+
+    def __init__(self, **kwargs):
+        self.widgets = kwargs.get("widgets", [])
+
+    def set_up_router(self):
+        from content_studio.router import content_studio_router
+
+        content_studio_router.register(
+            "api/dashboard",
+            DashboardViewSet,
+            basename="content_studio_dashboard",
+        )
+
+    def serialize(self):
+        return {
+            "widgets": [
+                {"name": w.__class__.__name__, "col_span": getattr(w, "col_span", 1)}
+                for w in self.widgets
+            ]
+        }
+
+
+class DashboardViewSet(ViewSet):
+    parser_classes = [JSONParser]
+    renderer_classes = [JSONRenderer]
+
+    def __init__(self, *args, **kwargs):
+        super(ViewSet, self).__init__()
+        admin_site = cs_settings.ADMIN_SITE
+
+        self.dashboard = admin_site.dashboard
+        self.authentication_classes = [
+            admin_site.token_backend.active_backend.authentication_class
+        ]
+
+    @action(detail=False, url_path="(?P<name>[^/.]+)")
+    def get(self, request, name=None):
+        widget = None
+
+        for w in self.dashboard.widgets:
+            if name == w.__class__.__name__.lower():
+                widget = w
+
+        if not widget:
+            raise NotFound()
+
+        return Response(data=widget.get_data(request))

content_studio/dashboard/activity_log.py

@@ -0,0 +1,35 @@
+from content_studio.serializers import ContentSerializer
+from django.contrib.admin.models import LogEntry
+from rest_framework import serializers
+
+
+class LogEntrySerializer(ContentSerializer):
+    object_model = serializers.SerializerMethodField()
+
+    class Meta:
+        model = LogEntry
+        fields = [
+            "id",
+            "action_flag",
+            "action_time",
+            "user",
+            "object_id",
+            "object_repr",
+            "object_model",
+        ]
+
+    def get_object_model(self, obj):
+        return f"{obj.content_type.app_label}.{obj.content_type.model}"
+
+
+class ActivityLogWidget:
+    """
+    Widget for showing activity logs.
+    """
+
+    col_span = 2
+
+    def get_data(self, request):
+        return LogEntrySerializer(
+            LogEntry.objects.all().order_by("-action_time")[0:5], many=True
+        ).data

content_studio/filters.py

@@ -0,0 +1,124 @@
+from decimal import Decimal
+
+from django.db import models
+from rest_framework.exceptions import ParseError
+from rest_framework.filters import BaseFilterBackend
+
+from .utils import flatten
+
+
+class LookupFilter(BaseFilterBackend):
+    """
+    A permissive filter backend that basically allows every supported lookup
+    for a given field. Automatically handles multi-value lookups and booleans.
+    Also supports exclusion.
+    """
+
+    MULTI_VALUE_LOOKUPS = ["in", "range"]
+
+    EXCLUDE_SYMBOL = "~"
+
+    NON_FILTER_FIELDS = [
+        "search",
+        "limit",
+        "page",
+    ]
+
+    def filter_queryset(self, request, queryset, view):
+        """
+        Build the queryset based on the query params and the view's model.
+        Only apply filters in list endpoints.
+        """
+        if getattr(view, "action", None) == "list":
+            try:
+                filter_kwargs, exclude_kwargs = self.get_filter_kwargs(
+                    model_class=view.queryset.model,
+                    query_params=request.query_params,
+                )
+            except Exception as e:
+                print(e)
+                raise ParseError(detail="Invalid filter parameters")
+            return queryset.filter(**filter_kwargs).exclude(**exclude_kwargs).distinct()
+
+        return queryset
+
+    def get_filter_kwargs(self, model_class, query_params):
+        filter_kwargs = {}
+        exclude_kwargs = {}
+
+        field_lookups = self.get_field_lookups(model_class=model_class)
+
+        for key, value in query_params.lists():
+            if key in self.NON_FILTER_FIELDS:
+                continue
+            # By default Django supports repeated multi-values (e.g. `a=1&a=2`)
+            # but we allow for comma-seperated multi-values as well (e.g. `a=1,2`).
+            value = flatten([param.split(",") for param in value])
+            is_exclude = key.startswith(self.EXCLUDE_SYMBOL)
+            # The first part of a key is considered the field name
+            field_name = key.split("__")[0]
+            # Get the model field.
+            field = model_class._meta.get_field(field_name)
+            # Get the allowed lookups for this field.
+            lookups = field_lookups.get(field_name, [])
+            try:
+                # The last part of a key is considered its lookup
+                # but it's not required.
+                lookup = key.split("__")[-1]
+                if lookup not in lookups:
+                    lookup = None
+            except IndexError:
+                lookup = None
+
+            # Some lookups allow multiple values, otherwise
+            # the first value is used.
+            is_multi = lookup in self.MULTI_VALUE_LOOKUPS
+            # Depending on the field type we cast the value to
+            # its correct type (i.e. number, boolean, etc.).
+            if is_multi:
+                casted_value = [self.cast_field_value(v, field) for v in value]
+            elif lookup == "isnull":
+                casted_value = value[0] in ["1", "true", "on"]
+            else:
+                casted_value = self.cast_field_value(value[0], field)
+
+            if is_exclude:
+                exclude_kwargs[key] = casted_value
+            else:
+                filter_kwargs[key] = casted_value
+
+        return filter_kwargs, exclude_kwargs
+
+    @staticmethod
+    def get_field_lookups(model_class):
+        """
+        Allow all supported lookups.
+        """
+        field_lookups = {}
+        for model_field in model_class._meta.get_fields():
+            lookup_list = model_field.get_lookups().keys()
+            field_lookups[model_field.name] = lookup_list
+        return field_lookups
+
+    def cast_field_value(self, value: str, field):
+        value = value.strip().lower()
+
+        if isinstance(field, models.BooleanField):
+            if value in ["1", "true", "on"]:
+                return True
+            if value in ["0", "false", "off"]:
+                return False
+        if isinstance(field, models.NullBooleanField):
+            if value in ["null", "none", "empty"]:
+                return None
+
+        if isinstance(field, models.IntegerField):
+            return int(value)
+
+        if isinstance(field, models.DecimalField):
+            return Decimal(value)
+
+        if isinstance(field, models.FloatField):
+            return float(value)
+
+        return value