django-content-studio 1.0.0a1__py3-none-any.whl → 1.0.0b1.post1__py3-none-any.whl

content_studio/__init__.py

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

content_studio/admin.py

@@ -1,53 +1,151 @@
-from django.contrib.admin import *
+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 .dashboard import Dashboard
+from . import widgets, formats
 from .form import FormSet, FormSetGroup
 from .login_backends import LoginBackendManager
 from .token_backends import TokenBackendManager
+from .utils import get_related_field_name
+
+register = admin.register
+
+
+class StackedInline(admin.StackedInline):
+    pass
+
 
+class TabularInline(admin.TabularInline):
+    pass
 
-class AdminSite(AdminSite):
+
+class AdminSite(admin.AdminSite):
     """
-    Enhanced admin site for Django Content Studio and integration with
-    Django Content Framework.
+    Enhanced admin site for Django Content Studio.
     """
 
     token_backend = TokenBackendManager()
 
     login_backend = LoginBackendManager()
 
-    dashboard = Dashboard()
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    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(ModelAdmin):
+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 | str]] = []
 
     # Configure the sidebar in the edit-view.
     edit_sidebar: list[type[FormSet | str]] = []
 
+    icon = None
+
     def save_model(self, request, obj, form, change):
         if hasattr(obj, "edited_by"):
             obj.edited_by = request.user
@@ -88,14 +186,38 @@ class AdminSerializer:
 
     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),
@@ -152,3 +274,25 @@ class AdminSerializer:
             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

@@ -1,9 +1,10 @@
 from django.apps import AppConfig
 from django.contrib import admin
-from rest_framework import serializers
 
-from headless.utils import is_runserver
 from . import VERSION
+from .paginators import ContentPagination
+from .settings import cs_settings
+from .utils import is_runserver
 
 
 class DjangoContentStudioConfig(AppConfig):
@@ -29,31 +30,71 @@ class DjangoContentStudioConfig(AppConfig):
                 ":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 .viewsets import BaseModelViewSet
-        from .router import content_studio_router
         from .utils import log
 
-        for _model, admin_model in admin.site._registry.items():
-
-            class Serializer(serializers.ModelSerializer):
-                class Meta:
-                    model = _model
-                    fields = "__all__"
+        for model, admin_model in admin.site._registry.items():
+            self._create_view_set(model, admin_model)
 
-            class ViewSet(BaseModelViewSet):
-                serializer_class = Serializer
-                queryset = _model.objects.all()
+            for inline in admin_model.inlines:
+                self._create_view_set(
+                    parent=model, model=inline.model, admin_model=inline
+                )
 
-            content_studio_router.register(
-                f"api/content/{_model._meta.label_lower}",
-                ViewSet,
-                f"content_studio_api-{_model._meta.label_lower}",
-            )
         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,34 @@
+from django.contrib.admin.models import LogEntry
+from rest_framework import serializers
+
+from content_studio.serializers import ContentSerializer
+
+
+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()[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

content_studio/form.py

@@ -1,16 +1,23 @@
+###
+# Form field classes are used for grouping, ordering and laying out fields.
+###
+
+
 class Field:
     """
     Field class for configuring the fields in content edit views in Django Content Studio.
     """
 
-    def __init__(self, name: str, col_span: int = 1):
+    def __init__(self, name: str, col_span: int = 1, label: str = None):
         self.name = name
         self.col_span = col_span
+        self.label = label
 
     def serialize(self):
         return {
             "name": self.name,
             "col_span": self.col_span,
+            "label": self.label,
         }
 
 
@@ -20,18 +27,23 @@ class FieldLayout:
     """
 
     def __init__(self, fields: list[str | Field] = None, columns: int = 1):
-        self.fields = fields or []
+        self.fields = [self._normalize_field(f) for f in fields] if fields else []
         self.columns = columns
 
     def serialize(self):
         return {
-            "fields": [
-                field.serialize() if isinstance(field, Field) else field
-                for field in self.fields
-            ],
+            "fields": [field.serialize() for field in self.fields],
             "columns": self.columns,
         }
 
+    def _normalize_field(self, field):
+        if isinstance(field, str):
+            return Field(field)
+        elif isinstance(field, Field):
+            return field
+        else:
+            raise ValueError(f"Invalid field: {field}. Must be a string or Field.")
+
 
 class FormSet:
     """
@@ -47,18 +59,27 @@ class FormSet:
     ):
         self.title = title
         self.description = description
-        self.fields = fields or []
+        self.fields = [self._normalize_field(f) for f in fields] if fields else []
 
     def serialize(self):
         return {
             "title": self.title,
             "description": self.description,
-            "fields": [
-                field.serialize() if isinstance(field, (Field, FieldLayout)) else field
-                for field in self.fields
-            ],
+            "fields": [field.serialize() for field in self.fields],
         }
 
+    def _normalize_field(self, field):
+        if isinstance(field, str):
+            return Field(field)
+        elif isinstance(field, Field):
+            return field
+        elif isinstance(field, FieldLayout):
+            return field
+        else:
+            raise ValueError(
+                f"Invalid field: {field}. Must be a string, Field or FieldLayout."
+            )
+
 
 class FormSetGroup:
     """