django-content-studio 1.0.0a1__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

content_studio/formats.py

@@ -0,0 +1,59 @@
+###
+# Formats determine how fields are displayed in Django Content Studio.
+# Each Django model field has a default format, but this can be
+# overridden in the admin model.
+###
+
+
+class BaseFormat:
+    @classmethod
+    def serialize(cls):
+        return {"name": cls.__name__}
+
+
+class ForeignKeyFormat(BaseFormat):
+    pass
+
+
+class MediaFormat(BaseFormat):
+    pass
+
+
+class TextFormat(BaseFormat):
+    pass
+
+
+class HtmlFormat(BaseFormat):
+    pass
+
+
+class BooleanFormat(BaseFormat):
+    pass
+
+
+class DateFormat(BaseFormat):
+    pass
+
+
+class DateTimeFormat(BaseFormat):
+    pass
+
+
+class TimeFormat(BaseFormat):
+    pass
+
+
+class NumberFormat(BaseFormat):
+    pass
+
+
+class FileSizeFormat(BaseFormat):
+    pass
+
+
+class TagFormat(BaseFormat):
+    pass
+
+
+class JSONFormat(BaseFormat):
+    pass

content_studio/login_backends/username_password.py

@@ -29,12 +29,15 @@ class UsernamePasswordViewSet(ViewSet):
             password=serializer.validated_data["password"],
         )
 
-        if user is None or not user.is_active:
-            raise PermissionDenied()
+        if user is None:
+            raise PermissionDenied(detail="Invalid username or password.")
+
+        if not user.is_active:
+            raise PermissionDenied(detail="User account is disabled.")
 
         from ..admin import admin_site
 
-        return admin_site.auth_backend.active_backend.get_response_for_user(user)
+        return admin_site.token_backend.active_backend.get_response_for_user(user)
 
 
 class UsernamePasswordBackend:

content_studio/media_library/serializers.py

@@ -0,0 +1,25 @@
+from rest_framework import serializers
+
+from content_studio.settings import cs_settings
+
+
+class MediaItemSerializer(serializers.ModelSerializer):
+    thumbnail = serializers.SerializerMethodField()
+
+    class Meta:
+        model = cs_settings.MEDIA_LIBRARY_MODEL
+        fields = "__all__"
+
+    def get_thumbnail(self, obj):
+        admin_site = cs_settings.ADMIN_SITE
+
+        if admin_site and obj.type == "image":
+            return admin_site.get_thumbnail(obj)
+
+        return None
+
+
+class MediaFolderSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = cs_settings.MEDIA_LIBRARY_FOLDER_MODEL
+        fields = ["id", "name", "parent"]

content_studio/media_library/viewsets.py

@@ -0,0 +1,132 @@
+from rest_framework import status, exceptions
+from rest_framework.decorators import action
+from rest_framework.filters import OrderingFilter, SearchFilter
+from rest_framework.parsers import JSONParser, MultiPartParser
+from rest_framework.permissions import DjangoModelPermissions
+from rest_framework.renderers import JSONRenderer
+from rest_framework.response import Response
+from rest_framework.viewsets import ModelViewSet
+
+from content_studio.paginators import ContentPagination
+from content_studio.settings import cs_settings
+from .serializers import MediaItemSerializer, MediaFolderSerializer
+
+
+class MediaLibraryViewSet(ModelViewSet):
+    _media_model = None
+    lookup_field = "id"
+    parser_classes = [JSONParser, MultiPartParser]
+    renderer_classes = [JSONRenderer]
+    permission_classes = [DjangoModelPermissions]
+    filter_backends = [SearchFilter, OrderingFilter]
+    pagination_class = ContentPagination
+
+    def __init__(self, *args, **kwargs):
+        super(MediaLibraryViewSet, self).__init__()
+
+        admin_site = cs_settings.ADMIN_SITE
+
+        self.authentication_classes = [
+            admin_site.token_backend.active_backend.authentication_class
+        ]
+
+    def get_queryset(self):
+        if not self._media_model:
+            self._media_model = cs_settings.MEDIA_LIBRARY_MODEL
+
+        if not self._media_model:
+            raise exceptions.MethodNotAllowed(
+                method="GET", detail="Media model not defined."
+            )
+
+        folder = self.request.query_params.get("folder", None)
+        qs = self._media_model.objects.all()
+
+        if folder:
+            if folder == "root":
+                return qs.filter(folder__isnull=True)
+            return qs.filter(folder=folder)
+
+        return qs
+
+    def get_serializer_class(self):
+        if self._media_model:
+            return MediaItemSerializer
+
+        raise exceptions.MethodNotAllowed(
+            method="GET", detail="Media model not defined."
+        )
+
+
+class MediaFolderViewSet(ModelViewSet):
+    _folder_model = None
+    lookup_field = "id"
+    parser_classes = [JSONParser]
+    renderer_classes = [JSONRenderer]
+    permission_classes = [DjangoModelPermissions]
+    filter_backends = [SearchFilter, OrderingFilter]
+    pagination_class = ContentPagination
+
+    def __init__(self, *args, **kwargs):
+        super(MediaFolderViewSet, self).__init__()
+
+        admin_site = cs_settings.ADMIN_SITE
+
+        self.authentication_classes = [
+            admin_site.token_backend.active_backend.authentication_class
+        ]
+
+    def get_queryset(self):
+        if not self._folder_model:
+            self._folder_model = cs_settings.MEDIA_LIBRARY_FOLDER_MODEL
+
+        if not self._folder_model:
+            raise exceptions.MethodNotAllowed(
+                method="GET", detail="Media folder model not defined."
+            )
+
+        parent = self.request.query_params.get("parent", None)
+        qs = self._folder_model.objects.all()
+
+        if self.action != "list":
+            return qs
+
+        # The list endpoint is always within the scope of a folder
+        if not parent:
+            return qs.filter(parent__isnull=True)
+        return qs.filter(parent=parent)
+
+    def get_serializer_class(self):
+        if self._folder_model:
+            return MediaFolderSerializer
+
+        raise exceptions.MethodNotAllowed(
+            method="GET", detail="Media folder model not defined."
+        )
+
+    @action(methods=["get"], detail=False, url_path="path")
+    def get(self, request, *args, **kwargs):
+
+        if not self._folder_model:
+            self._folder_model = cs_settings.MEDIA_LIBRARY_FOLDER_MODEL
+
+        if not self._folder_model:
+            raise exceptions.MethodNotAllowed(
+                method="GET", detail="Folder model not defined."
+            )
+
+        folder_id = request.query_params.get("folder", None)
+
+        if not folder_id:
+            return Response(data=[])
+
+        try:
+            folder = self._folder_model.objects.get(pk=folder_id)
+            path = []
+            while folder:
+                path.insert(0, folder)
+                folder = folder.parent
+
+            return Response(data=MediaFolderSerializer(path, many=True).data)
+        except self._folder_model.DoesNotExist:
+            return Response(status=status.HTTP_404_NOT_FOUND)

content_studio/models.py

@@ -1,7 +1,5 @@
 from django.db import models
 
-from content_framework import fields as cf_fields
-from . import widgets
 from .utils import is_jsonable
 
 
@@ -9,61 +7,50 @@ class ModelSerializer:
     def __init__(self, model: type[models.Model]):
         self.model = model
 
-    widgets = {
-        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.BooleanWidget,
-        models.NullBooleanField: widgets.BooleanWidget,
-        cf_fields.MultipleChoiceField: widgets.MultipleChoiceWidget,
-        cf_fields.TagField: widgets.TagWidget,
-        cf_fields.HTMLField: widgets.RichTextWidget,
-        cf_fields.URLPathField: widgets.URLPathWidget,
-    }
-
     def serialize(self):
         model = self.model
 
         return {
-            "label": model._meta.label,
+            "label": model._meta.label_lower,
             "verbose_name": model._meta.verbose_name,
             "verbose_name_plural": model._meta.verbose_name_plural,
             "fields": self.get_fields(),
         }
 
     def get_fields(self):
-        fields = {}
+        fields = {
+            "__str__": {
+                "type": "CharField",
+                "readonly": True,
+            }
+        }
+        standard_fields = self.model._meta.fields
+        m2m_fields = self.model._meta.many_to_many
 
-        for field in self.model._meta.fields:
+        for field in standard_fields + m2m_fields:
             fields[field.name] = self.get_field(field)
 
         return fields
 
     def get_field(self, field):
-        widget = self.get_widget(field)
-
         data = {
             "verbose_name": field.verbose_name,
             "required": not field.null or not field.blank,
+            "type": field.__class__.__name__,
         }
 
+        if hasattr(field, "widget_class"):
+            data["widget_class"] = field.widget_class.__name__
+
+        if hasattr(field, "format_class"):
+            data["format_class"] = field.format_class.__name__
+
         if field.help_text:
             data["help_text"] = field.help_text
 
         if is_jsonable(field.default):
             data["default"] = field.default
 
-        if widget:
-            data["widget"] = widget
-
         if not field.editable:
             data["readonly"] = True
 
@@ -71,16 +58,16 @@ class ModelSerializer:
             data["primary_key"] = True
             data["readonly"] = True
 
+        if field.is_relation:
+            data["related_model"] = field.related_model._meta.label_lower
+
         if getattr(field, "choices", None) is not None:
             data["choices"] = field.choices
 
         if getattr(field, "max_length", None) is not None:
             data["max_length"] = field.max_length
 
-        return data
+        if getattr(field, "cs_get_field_attributes", None):
+            data.update(field.cs_get_field_attributes())
 
-    def get_widget(self, field):
-        try:
-            return self.widgets[field.__class__].__name__
-        except KeyError:
-            return None
+        return data

content_studio/paginators.py

@@ -0,0 +1,20 @@
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.response import Response
+
+
+class ContentPagination(PageNumberPagination):
+    page_size = 20
+    page_size_query_param = "limit"
+    max_page_size = 100
+
+    def get_paginated_response(self, data):
+        return Response(
+            {
+                "pagination": {
+                    "count": self.page.paginator.count,
+                    "current": self.page.number,
+                    "pages": self.page.paginator.num_pages,
+                },
+                "results": data,
+            }
+        )

content_studio/serializers.py

@@ -1,16 +1,118 @@
+import inspect
+
 from django.contrib.auth import get_user_model
 from rest_framework import serializers
+from rest_framework.relations import RelatedField
 
 user_model = get_user_model()
 
 
-class CurrentUserSerializer(serializers.ModelSerializer):
+class ContentRelatedField(RelatedField):
+
+    def to_representation(self, value):
+        from content_studio.settings import cs_settings
+
+        admin_site = cs_settings.ADMIN_SITE
+        data = {"id": value.id, "__str__": str(value)}
+
+        # Add file URL and media type if the model is a media library model.
+        if value.__class__ is cs_settings.MEDIA_LIBRARY_MODEL:
+            data["file"] = value.file.url
+            data["type"] = value.type
+            data["thumbnail"] = admin_site.get_thumbnail(value)
+
+        return data
+
+    def to_internal_value(self, data):
+        return self.get_queryset().get(id=data["id"])
+
+
+class ContentSerializer(serializers.ModelSerializer):
+    __str__ = serializers.CharField(read_only=True)
+    serializer_related_field = ContentRelatedField
+
+    def get_field_names(self, declared_fields, info):
+        """
+        Override to automatically add model properties to the fields list.
+        """
+        # Get the default fields from parent class
+        fields = super().get_field_names(declared_fields, info)
+
+        # If fields is '__all__', we need to expand it
+        if fields == "__all__":
+            fields = list(super().get_field_names(declared_fields, info))
+        else:
+            fields = list(fields)
+
+        # Get all properties from the model
+        model_properties = self._get_model_properties()
+
+        # Add properties that aren't already in fields
+        for prop_name in model_properties:
+            if prop_name not in fields and prop_name not in declared_fields:
+                fields.append(prop_name)
+
+        return fields
+
+    def _get_model_properties(self):
+        """
+        Extract all @property attributes from the model class.
+        """
+        model = self.Meta.model
+        properties = []
+
+        # Inspect the model class and its parent classes
+        for klass in inspect.getmro(model):
+            if klass == object:
+                break
+
+            for name, obj in inspect.getmembers(klass):
+                # Check if it's a property and not private/protected
+                if isinstance(obj, property) and not name.startswith("_"):
+                    if name not in properties:
+                        properties.append(name)
+
+        return properties
+
+    def build_property_field(self, field_name, model_class):
+        """
+        Create a ReadOnlyField for property attributes.
+        """
+        return serializers.ReadOnlyField, {}
+
+    def build_field(self, field_name, info, model_class, nested_depth):
+        """
+        Override to handle property fields.
+        """
+        # Check if this is a property
+        if hasattr(model_class, field_name):
+            attr = getattr(model_class, field_name)
+            if isinstance(attr, property):
+                return self.build_property_field(field_name, model_class)
+
+        # Fall back to default behavior for regular fields
+        return super().build_field(field_name, info, model_class, nested_depth)
+
+
+class SessionUserSerializer(serializers.ModelSerializer):
+    username = serializers.CharField(source=user_model.USERNAME_FIELD)
+
+    class Meta:
+        model = user_model
+        fields = (
+            "id",
+            "username",
+            "first_name",
+            "last_name",
+        )
+
+
+class UserSerializer(serializers.ModelSerializer):
+
     class Meta:
         model = user_model
         fields = (
             "id",
-            user_model.USERNAME_FIELD,
-            user_model.EMAIL_FIELD,
             "first_name",
             "last_name",
         )

content_studio/settings.py

@@ -21,19 +21,25 @@ from django.utils.module_loading import import_string
 SETTINGS_NAMESPACE = "CONTENT_STUDIO"
 
 DEFAULTS = {
+    "ADMIN_SITE": "content_studio.admin.admin_site",
     "LOGIN_BACKENDS": [
         "content_studio.login_backends.UsernamePasswordBackend",
     ],
-    "EDITED__BY_ATTR": "edited_by",
+    "EDITED_BY_ATTR": "edited_by",
     "EDITED_AT_ATTR": "edited_at",
     "CREATED_BY_ATTR": "created_by",
     "CREATED_AT_ATTR": "created_at",
+    "MEDIA_LIBRARY_MODEL": None,
+    "MEDIA_LIBRARY_FOLDER_MODEL": None,
 }
 
 
 # List of settings that may be in string import notation.
 IMPORT_STRINGS = [
+    "ADMIN_SITE",
     "LOGIN_BACKENDS",
+    "MEDIA_LIBRARY_MODEL",
+    "MEDIA_LIBRARY_FOLDER_MODEL",
 ]
 
 

content_studio/templates/content_studio/index.html

@@ -8,8 +8,7 @@
     <title>Django Content Studio</title>
     <script>
         window.DCS_STATIC_PREFIX = "{% static '' %}content_studio/";
-        window.DCS_BASENAME = "{% url 'content_studio' %}";
-        window.DCS_API_URL = "{% url 'headless_rest' %}";
+        window.DCS_BASENAME = "{% url 'content_studio_web' %}";
     </script>
   <script type="module" crossorigin src="{% static 'content_studio/assets/index.js' %}"></script>
   <link rel="stylesheet" crossorigin href="{% static 'content_studio/assets/index.css' %}">

content_studio/token_backends/jwt.py

@@ -1,6 +1,10 @@
 from rest_framework.decorators import action
 from rest_framework.response import Response
 from rest_framework.viewsets import ViewSet
+from rest_framework_simplejwt.authentication import JWTAuthentication
+from rest_framework_simplejwt.settings import api_settings as simplejwt_settings
+from rest_framework_simplejwt.tokens import RefreshToken
+from rest_framework_simplejwt.views import TokenRefreshView
 
 
 class SimpleJwtViewSet(ViewSet):
@@ -8,7 +12,6 @@ class SimpleJwtViewSet(ViewSet):
         detail=False, methods=["post"], permission_classes=[], authentication_classes=[]
     )
     def refresh(self, request):
-        from rest_framework_simplejwt.views import TokenRefreshView
 
         view_instance = TokenRefreshView()
         view_instance.request = request
@@ -18,22 +21,15 @@ class SimpleJwtViewSet(ViewSet):
 
 class SimpleJwtBackend:
     name = "Simple JWT"
-    authentication_class = None
+    authentication_class = JWTAuthentication
     view_set = SimpleJwtViewSet
 
-    def __init__(self):
-        from rest_framework_simplejwt.authentication import JWTAuthentication
-
-        self.authentication_class = JWTAuthentication
-
     @classmethod
     def get_info(cls):
 
-        from rest_framework_simplejwt.settings import api_settings as simplejwt_settings
-
         return {
             "type": cls.__name__,
-            "settings": {
+            "config": {
                 "ACCESS_TOKEN_LIFETIME": simplejwt_settings.ACCESS_TOKEN_LIFETIME.total_seconds(),
             },
         }
@@ -49,7 +45,6 @@ class SimpleJwtBackend:
 
     @classmethod
     def get_response_for_user(cls, user):
-        from rest_framework_simplejwt.tokens import RefreshToken
 
         refresh = RefreshToken.for_user(user)
 

content_studio/urls.py

@@ -1,12 +1,21 @@
 from django.urls import re_path
 
+from .media_library.viewsets import MediaLibraryViewSet, MediaFolderViewSet
 from .router import content_studio_router
 from .views import ContentStudioWebAppView, AdminApiViewSet
 
 content_studio_router.register("api", AdminApiViewSet, "content_studio_admin")
+content_studio_router.register(
+    "api/media-library/items", MediaLibraryViewSet, "content_studio_media_library_items"
+)
+content_studio_router.register(
+    "api/media-library/folders",
+    MediaFolderViewSet,
+    "content_studio_media_library_folders",
+)
 
-urlpatterns = content_studio_router.urls + [
+urlpatterns = [
     re_path(
         "^(?!api).*$", ContentStudioWebAppView.as_view(), name="content_studio_web"
     ),
-]
+] + content_studio_router.urls

content_studio/utils.py

@@ -10,6 +10,10 @@ def log(*args, **kwargs):
     console.print(*args, **kwargs)
 
 
+def flatten(xss):
+    return [x for xs in xss for x in xs]
+
+
 def is_runserver():
     """
     Checks if the Django application is started as a server.
@@ -28,3 +32,31 @@ def is_jsonable(x):
         return True
     except (TypeError, OverflowError):
         return False
+
+
+def get_related_field_name(inline, parent_model):
+    """
+    Get the name of the foreign key field in the inline model.
+    """
+    if inline.fk_name:
+        return inline.fk_name
+
+    # Let Django figure it out
+
+    opts = inline.model._meta
+
+    # Find all foreign keys pointing to parent model
+    fks = [
+        f
+        for f in opts.get_fields()
+        if f.many_to_one and f.remote_field.model == parent_model
+    ]
+
+    if len(fks) == 1:
+        return fks[0].name
+    elif len(fks) == 0:
+        raise ValueError(
+            f"No foreign key found in {inline.model} pointing to {parent_model}"
+        )
+    else:
+        raise ValueError(f"Multiple foreign keys found. Specify fk_name on the inline.")