django-camomilla-cms 5.8.5__py2.py3-none-any.whl → 6.0.0__py2.py3-none-any.whl

camomilla/serializers/base/__init__.py

@@ -1,35 +1,39 @@
-from hvad.contrib.restframework import TranslatableModelSerializer
 from rest_framework import serializers
 
-from ..fields import FieldsOverrideMixin, TranslatableFieldsOverrideMixin
-from ..mixins import (
+from camomilla.serializers.mixins import (
     JSONFieldPatchMixin,
-    LangInfoMixin,
+    NestMixin,
     OrderingMixin,
     SetupEagerLoadingMixin,
-    TranslationSetMixin,
-    NestMixin,
+    FilterFieldsMixin,
+    FieldsOverrideMixin,
+    TranslationsMixin,
 )
 
 
 class BaseModelSerializer(
+    SetupEagerLoadingMixin,
     NestMixin,
+    FilterFieldsMixin,
     FieldsOverrideMixin,
     JSONFieldPatchMixin,
     OrderingMixin,
-    SetupEagerLoadingMixin,
+    TranslationsMixin,
     serializers.ModelSerializer,
 ):
+    """
+    This is the base serializer for all the models.
+    It adds support for:
+    - nesting translations fields under a "translations" field
+    - overriding related fields with auto-generated serializers
+    - patching JSONField
+    - ordering
+    - eager loading
+    """
+
     pass
 
 
-class BaseTranslatableModelSerializer(
-    NestMixin,
-    TranslatableFieldsOverrideMixin,
-    JSONFieldPatchMixin,
-    OrderingMixin,
-    LangInfoMixin,
-    TranslationSetMixin,
-    TranslatableModelSerializer,
-):
-    pass
+__all__ = [
+    "BaseModelSerializer",
+]

camomilla/serializers/content_type.py

@@ -0,0 +1,17 @@
+from django.contrib.contenttypes.models import ContentType
+from rest_framework import serializers
+
+
+class ContentTypeSerializer(serializers.ModelSerializer):
+    verbose_name = serializers.SerializerMethodField()
+    verbose_name_plural = serializers.SerializerMethodField()
+
+    def get_verbose_name(self, obj):
+        return obj.model_class()._meta.verbose_name.title()
+
+    def get_verbose_name_plural(self, obj):
+        return obj.model_class()._meta.verbose_name_plural.title()
+
+    class Meta:
+        model = ContentType
+        fields = "__all__"

camomilla/serializers/fields/__init__.py

@@ -1,23 +1,9 @@
+from .file import FileField, ImageField
 from .related import RelatedField
-from .file import ImageField, FileField
-from hvad.contrib.restframework import TranslatableModelSerializer
-from django.db import models
-from rest_framework import serializers
 
 
-class FieldsOverrideMixin:
-    serializer_field_mapping = {
-        **serializers.ModelSerializer.serializer_field_mapping,
-        models.FileField: FileField,
-        models.ImageField: ImageField,
-    }
-    serializer_related_field = RelatedField
-
-
-class TranslatableFieldsOverrideMixin(FieldsOverrideMixin):
-
-    serializer_field_mapping = {
-        **TranslatableModelSerializer.serializer_field_mapping,
-        models.FileField: FileField,
-        models.ImageField: ImageField,
-    }
+__all__ = [
+    "FileField",
+    "ImageField",
+    "RelatedField",
+]

camomilla/serializers/fields/file.py

@@ -4,6 +4,11 @@ from rest_framework.fields import Field
 
 
 class SafeFileFieldMixin(Field):
+    """
+    This mixin prevents errors when trying to upload a file passing its current url.
+    In such cases, the current file will be kept.
+    """
+
     def to_internal_value(self, data):
         current = getattr(self.parent.instance, self.field_name, None)
         if (

camomilla/serializers/fields/related.py

@@ -3,7 +3,22 @@ from rest_framework import serializers, relations
 
 
 class RelatedField(serializers.PrimaryKeyRelatedField):
+    """
+    This field helps to serialize and deserialize related data.
+    It serializes related data building a nested serializer.
+    Allowing insertions with both nested and plain data.
+
+
+    For example it accepts as input data both:
+    ```json
+    {"related_field": 1}
+    {"related_field": {"id": 1, "field": "value"}}
+    ```
+
+    """
+
     def __init__(self, **kwargs):
+        self.inherited_fields_filter = kwargs.pop("inherited_fields_filter", [])
         self.serializer = kwargs.pop("serializer", None)
         self.lookup = kwargs.pop("lookup", "id")
         if self.serializer is not None:
@@ -28,7 +43,10 @@ class RelatedField(serializers.PrimaryKeyRelatedField):
 
     def to_representation(self, instance):
         if self.serializer:
-            return self.serializer(instance, context=self.context).data
+            kwargs = {"context": self.context}
+            if self.inherited_fields_filter:
+                kwargs["inherited_fields_filter"] = self.inherited_fields_filter
+            return self.serializer(instance, **kwargs).data
         return super().to_representation(instance)
 
     def to_internal_value(self, data):
@@ -79,9 +97,11 @@ class RelatedField(serializers.PrimaryKeyRelatedField):
                     for item in child.get_queryset().filter(
                         **{
                             f"{child.lookup}__in": [
-                                item.get(child.lookup, None)
-                                if isinstance(item, dict)
-                                else item
+                                (
+                                    item.get(child.lookup, None)
+                                    if isinstance(item, dict)
+                                    else item
+                                )
                                 for item in data
                             ]
                         }

camomilla/serializers/media.py

@@ -1,11 +1,11 @@
 from rest_framework import serializers
 
-from ..models import Media, MediaFolder
-from ..storages import OverwriteStorage
-from .base import BaseTranslatableModelSerializer
+from camomilla.models import Media, MediaFolder
+from camomilla.serializers.base import BaseModelSerializer
+from camomilla.storages import OverwriteStorage
 
 
-class MediaListSerializer(BaseTranslatableModelSerializer):
+class MediaListSerializer(BaseModelSerializer):
     is_image = serializers.SerializerMethodField("get_is_image")
 
     def get_is_image(self, obj):
@@ -16,7 +16,7 @@ class MediaListSerializer(BaseTranslatableModelSerializer):
         fields = "__all__"
 
 
-class MediaSerializer(BaseTranslatableModelSerializer):
+class MediaSerializer(BaseModelSerializer):
     links = serializers.SerializerMethodField("get_linked_instances")
     is_image = serializers.SerializerMethodField("get_is_image")
 
@@ -29,8 +29,6 @@ class MediaSerializer(BaseTranslatableModelSerializer):
         links = obj.get_foreign_fields()
         for link in links:
             manager = getattr(obj, link)
-            if hasattr(manager, "language"):
-                manager = manager.language()
             for item in manager.all():
                 if item.__class__.__name__ != "MediaTranslation":
                     result.append(
@@ -57,7 +55,7 @@ class MediaSerializer(BaseTranslatableModelSerializer):
         return obj.is_image
 
 
-class MediaFolderSerializer(BaseTranslatableModelSerializer):
+class MediaFolderSerializer(BaseModelSerializer):
     icon = MediaSerializer(read_only=True)
 
     class Meta:

camomilla/serializers/menu.py

@@ -0,0 +1,17 @@
+from camomilla.models import Menu
+from camomilla.serializers.base import BaseModelSerializer
+
+
+class MenuSerializer(BaseModelSerializer):
+    def get_default_field_names(self, *args):
+        field_names = super().get_default_field_names(*args)
+        self.action = getattr(
+            self, "action", self.context and self.context.get("action", "list")
+        )
+        if self.action == "list":
+            return [f for f in field_names if f != "nodes"]
+        return field_names
+
+    class Meta:
+        model = Menu
+        fields = "__all__"

camomilla/serializers/mixins/__init__.py

@@ -1,187 +1,23 @@
-import django
-from django.conf import settings
-from django.db.models.aggregates import Max
-from django.db.models.functions import Coalesce
-from django.utils import translation
-from hvad.contrib.restframework import TranslatableModelSerializer, TranslationsMixin
-from hvad.models import TranslatableModel
-from rest_framework import serializers
-from rest_framework.utils import model_meta
-
-from ...fields import ORDERING_ACCEPTED_FIELDS
-from ...utils import dict_merge
-from ..fields import FieldsOverrideMixin, TranslatableFieldsOverrideMixin
-from ..fields.related import RelatedField
-
-if django.VERSION >= (4, 0):
-    from django.db.models import JSONField as DjangoJSONField
-else:
-    from django.contrib.postgres.fields import JSONField as DjangoJSONField
-
-
-class LangInfoMixin(metaclass=serializers.SerializerMetaclass):
-    lang_info = serializers.SerializerMethodField("get_lang_info", read_only=True)
-
-    def get_lang_info(self, obj, *args, **kwargs):
-        languages = []
-        for key, language in settings.LANGUAGES:
-            languages.append({"id": key, "name": language})
-        return {
-            "default": settings.LANGUAGE_CODE,
-            "active": translation.get_language(),
-            "translated_in": obj.translations.all_languages(),
-            "site_languages": languages,
-        }
-
-    def get_default_field_names(self, *args):
-        field_names = super().get_default_field_names(*args)
-        self.action = getattr(
-            self, "action", self.context and self.context.get("action", "list")
-        )
-        if self.action != "retrieve":
-            return [f for f in field_names if f != "lang_info"]
-        return field_names
-
-
-class TranslationSetMixin(TranslationsMixin):
-    def get_default_field_names(self, *args):
-        field_names = super(TranslationsMixin, self).get_default_field_names(*args)
-        self.action = getattr(
-            self, "action", self.context and self.context.get("action", "list")
-        )
-        if self.action != "list":
-            field_names += [self.Meta.model._meta.translations_accessor]
-        return field_names
-
-
-class SetupEagerLoadingMixin:
-    @staticmethod
-    def setup_eager_loading(queryset):
-        return queryset
-
-
-class OrderingMixin:
-    def get_max_order(self, order_field):
-        return self.Meta.model.objects.aggregate(
-            max_order=Coalesce(Max(order_field), 0)
-        )["max_order"]
-
-    def _get_ordering_field_name(self):
-        try:
-            field_name = self.Meta.model._meta.ordering[0]
-            if field_name[0] == "-":
-                field_name = field_name[1:]
-            return field_name
-        except (AttributeError, IndexError):
-            return None
-
-    def build_standard_field(self, field_name, model_field):
-        field_class, field_kwargs = super().build_standard_field(
-            field_name, model_field
-        )
-        if (
-            isinstance(model_field, ORDERING_ACCEPTED_FIELDS)
-            and field_name == self._get_ordering_field_name()
-        ):
-            field_kwargs["default"] = self.get_max_order(field_name) + 1
-        return field_class, field_kwargs
-
-
-class JSONFieldPatchMixin:
-    def is_json_field(self, attr, value, info):
-        return (
-            attr in info.fields
-            and isinstance(info.fields[attr], DjangoJSONField)
-            and isinstance(value, dict)
-        )
-
-    def update(self, instance, validated_data):
-        if self.partial:
-            if isinstance(self, TranslationsMixin):
-                validated_data = self.merge_trans_jsonfields(instance, validated_data)
-            info = model_meta.get_field_info(instance)
-            for attr, value in validated_data.items():
-                if self.is_json_field(attr, value, info):
-                    validated_data[attr] = dict_merge(
-                        getattr(instance, attr, {}), value
-                    )
-        return super().update(instance, validated_data)
-
-    def merge_trans_jsonfields(self, instance, validated_data):
-        accessor = self.Meta.model._meta.translations_accessor
-        if isinstance(validated_data.get(accessor), dict):
-            translations = {
-                trans.language_code: trans
-                for trans in instance._meta.translations_model.objects.filter(
-                    master=instance,
-                    language_code__in=[
-                        lang
-                        for lang, val in validated_data[accessor].items()
-                        if isinstance(val, dict)
-                    ],
-                )
-            }
-            for lang, trans in translations.items():
-                info = model_meta.get_field_info(trans)
-                for attr, value in validated_data[accessor][lang].items():
-                    if self.is_json_field(attr, value, info):
-                        validated_data[accessor][lang][attr] = dict_merge(
-                            getattr(trans, attr, {}), value
-                        )
-        return validated_data
-
-
-DEFAULT_NESTING_DEPTH = getattr(settings, "CAMOMILLA_DRF_NESTING_DEPTH", 10)
-
-
-class NestMixin:
-    def __init__(self, *args, **kwargs):
-        self._depth = kwargs.pop("depth", None)
-        return super().__init__(*args, **kwargs)
-
-    def build_nested_field(self, field_name, relation_info, nested_depth):
-        return self.build_relational_field(field_name, relation_info, nested_depth)
-
-    def build_relational_field(
-        self, field_name, relation_info, nested_depth=DEFAULT_NESTING_DEPTH + 1
-    ):
-        nested_depth = nested_depth if self._depth is None else self._depth
-        field_class, field_kwargs = super().build_relational_field(
-            field_name, relation_info
-        )
-        if (
-            field_class is RelatedField and nested_depth > 1
-        ):  # stop recursion one step before the jump :P
-            field_kwargs["serializer"] = self.build_standard_model_serializer(
-                relation_info[1], nested_depth - 1
-            )
-        return field_class, field_kwargs
-
-    def build_standard_model_serializer(self, model, depth):
-        bases = (
-            NestMixin,
-            FieldsOverrideMixin,
-            JSONFieldPatchMixin,
-            OrderingMixin,
-            SetupEagerLoadingMixin,
-            serializers.ModelSerializer,
-        )
-        if issubclass(model, TranslatableModel):
-            bases = (
-                NestMixin,
-                TranslatableFieldsOverrideMixin,
-                JSONFieldPatchMixin,
-                OrderingMixin,
-                TranslatableModelSerializer,
-            )
-        return type(
-            f"{model.__name__}StandardSerializer",
-            bases,
-            {
-                "Meta": type(
-                    "Meta",
-                    (object,),
-                    {"model": model, "depth": depth, "fields": "__all__"},
-                )
-            },
-        )
+from .fields import FieldsOverrideMixin
+from .filter_fields import FilterFieldsMixin
+from .json import JSONFieldPatchMixin
+from .language import LangInfoMixin
+from .nesting import NestMixin
+from .optimize import SetupEagerLoadingMixin
+from .ordering import OrderingMixin
+from .page import AbstractPageMixin
+from .translation import TranslationsMixin, RemoveTranslationsMixin
+
+
+__all__ = [
+    "FieldsOverrideMixin",
+    "FilterFieldsMixin",
+    "JSONFieldPatchMixin",
+    "LangInfoMixin",
+    "NestMixin",
+    "SetupEagerLoadingMixin",
+    "OrderingMixin",
+    "AbstractPageMixin",
+    "TranslationsMixin",
+    "RemoveTranslationsMixin",
+]

camomilla/serializers/mixins/fields.py

@@ -0,0 +1,20 @@
+from django.db import models
+from rest_framework import serializers
+
+from structured.fields import StructuredJSONField as ModelStructuredJSONField
+from camomilla.serializers.fields import FileField, ImageField, RelatedField
+from structured.contrib.restframework import StructuredJSONField
+
+
+class FieldsOverrideMixin:
+    """
+    This mixin automatically overrides the fields of the serializer with camomilla's backed ones.
+    """
+
+    serializer_field_mapping = {
+        **serializers.ModelSerializer.serializer_field_mapping,
+        models.FileField: FileField,
+        models.ImageField: ImageField,
+        ModelStructuredJSONField: StructuredJSONField,
+    }
+    serializer_related_field = RelatedField

camomilla/serializers/mixins/filter_fields.py

@@ -0,0 +1,57 @@
+from rest_framework import serializers
+from camomilla.serializers.fields.related import RelatedField
+from collections import defaultdict
+
+
+class FilterFieldsMixin(serializers.ModelSerializer):
+    """
+    Mixin to filter fields from a serializer, including handling nested fields.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.inherited_fields_filter = kwargs.pop("inherited_fields_filter", [])
+        return super().__init__(*args, **kwargs)
+
+    inherited_fields_filter = []
+
+    def get_default_field_names(self, *args):
+        field_names = super().get_default_field_names(*args)
+        request = self.context.get("request", None)
+
+        if request is not None and request.method == "GET":
+            fields = request.query_params.get("fields", "").split(",")
+            fields = [f for f in fields if f != ""]
+            if len(self.inherited_fields_filter) > 0:
+                fields = self.inherited_fields_filter
+
+            self.filtered_fields = set()
+            self.childs_fields = defaultdict(set)
+            for field in fields:
+                if "__" in field:
+                    parent_field, child_field = field.split("__", 1)
+                    if parent_field in field_names:
+                        self.filtered_fields.add(parent_field)
+                        self.childs_fields[parent_field].add(child_field)
+                else:
+                    if field in field_names:
+                        self.filtered_fields.add(field)
+
+            if len(self.filtered_fields) > 0:
+                return list(self.filtered_fields)
+            else:
+                return field_names
+
+        return field_names
+
+    def build_field(self, field_name, info, model_class, nested_depth):
+        field_class, field_kwargs = super().build_field(
+            field_name, info, model_class, nested_depth
+        )
+        inherited_fields_filter = (
+            self.childs_fields.get(field_name, [])
+            if hasattr(self, "childs_fields")
+            else []
+        )
+        if len(inherited_fields_filter) > 0 and issubclass(field_class, RelatedField):
+            field_kwargs["inherited_fields_filter"] = list(inherited_fields_filter)
+        return field_class, field_kwargs

camomilla/serializers/mixins/json.py

@@ -0,0 +1,34 @@
+import django
+from rest_framework.utils import model_meta
+
+from camomilla.utils import dict_merge
+
+if django.VERSION >= (4, 0):
+    from django.db.models import JSONField as DjangoJSONField
+else:
+    from django.contrib.postgres.fields import JSONField as DjangoJSONField
+
+
+class JSONFieldPatchMixin:
+    """
+    This mixin allows to patch JSONField values during partial updates.
+    This means that, if a JSONField is present in the request and the requsest uses PATCH method,
+    the serializer will merge the new data with the old one.
+    """
+
+    def is_json_field(self, attr, value, info):
+        return (
+            attr in info.fields
+            and isinstance(info.fields[attr], DjangoJSONField)
+            and isinstance(value, dict)
+        )
+
+    def update(self, instance, validated_data):
+        if self.partial:
+            info = model_meta.get_field_info(instance)
+            for attr, value in validated_data.items():
+                if self.is_json_field(attr, value, info):
+                    validated_data[attr] = dict_merge(
+                        getattr(instance, attr, {}), value
+                    )
+        return super().update(instance, validated_data)

camomilla/serializers/mixins/language.py

@@ -0,0 +1,32 @@
+from django.conf import settings as django_settings
+from django.utils import translation
+from rest_framework import serializers
+
+
+# TODO: decide what to do with LangInfoMixin mixin!
+class LangInfoMixin(metaclass=serializers.SerializerMetaclass):
+    """
+    This mixin adds a "lang_info" field to the serializer.
+    This field contains information about the languages available in the site.
+    """
+
+    lang_info = serializers.SerializerMethodField("get_lang_info", read_only=True)
+
+    def get_lang_info(self, obj, *args, **kwargs):
+        languages = []
+        for key, language in django_settings.LANGUAGES:
+            languages.append({"id": key, "name": language})
+        return {
+            "default": django_settings.LANGUAGE_CODE,
+            "active": translation.get_language(),
+            "site_languages": languages,
+        }
+
+    def get_default_field_names(self, *args):
+        field_names = super().get_default_field_names(*args)
+        self.action = getattr(
+            self, "action", self.context and self.context.get("action", "list")
+        )
+        if self.action != "retrieve":
+            return [f for f in field_names if f != "lang_info"]
+        return field_names

camomilla/serializers/mixins/nesting.py

@@ -0,0 +1,35 @@
+from camomilla.serializers.fields.related import RelatedField
+from camomilla.serializers.utils import build_standard_model_serializer
+from camomilla import settings
+
+
+class NestMixin:
+    """
+    This mixin automatically creates nested serializers for relational fields.
+    The depth of the nesting can be set using the "depth" attribute of the Meta class.
+    If the depth is not set, the serializer will use the value coming from the settings.
+
+    CAMOMILLA = { "API": {"NESTING_DEPTH": 10} }
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._depth = kwargs.pop("depth", None)
+        return super().__init__(*args, **kwargs)
+
+    def build_nested_field(self, field_name, relation_info, nested_depth):
+        return self.build_relational_field(field_name, relation_info, nested_depth)
+
+    def build_relational_field(
+        self, field_name, relation_info, nested_depth=settings.API_NESTING_DEPTH + 1
+    ):
+        nested_depth = nested_depth if self._depth is None else self._depth
+        field_class, field_kwargs = super().build_relational_field(
+            field_name, relation_info
+        )
+        if (
+            field_class is RelatedField and nested_depth > 1
+        ):  # stop recursion one step before the jump :P
+            field_kwargs["serializer"] = build_standard_model_serializer(
+                relation_info[1], nested_depth - 1
+            )
+        return field_class, field_kwargs