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

camomilla/serializers/mixins/optimize.py

@@ -0,0 +1,91 @@
+from rest_framework.utils import model_meta
+
+
+class Optimizations:
+    only = set()
+    select_related = set()
+    prefetch_related = set()
+
+    def __init__(self):
+        self.only = set()
+        self.select_related = set()
+        self.prefetch_related = set()
+
+    def __str__(self):
+        return f"Optimizations(only={self.only}, select_related={self.select_related}, prefetch_related={self.prefetch_related})"
+
+
+def recursive_extract_optimizations(fields, info, max_depth=100) -> Optimizations:
+    optimizations = Optimizations()
+    if max_depth == 0:
+        return optimizations
+    for field in fields:
+        if "__" in field and field not in info.fields:
+            field_part_1, field_part_2 = field.split("__", 1)
+            if field_part_1 in info.relations:
+                field_info = info.relations[field_part_1]
+                nested_info = model_meta.get_field_info(field_info.related_model)
+                if field_info.to_many:
+                    optimizations.prefetch_related.add(field_part_1)
+                    optimizations.only.add(field_part_1)
+                else:
+                    optimizations.select_related.add(field_part_1)
+                    optimizations.only.add(field_part_1)
+                nested_optimizations = recursive_extract_optimizations(
+                    [field_part_2], nested_info, max_depth - 1
+                )
+
+                for nested_field in nested_optimizations.only:
+                    optimizations.only.add(f"{field_part_1}__{nested_field}")
+                for nested_field in nested_optimizations.select_related:
+                    optimizations.select_related.add(f"{field_part_1}__{nested_field}")
+                for nested_field in nested_optimizations.prefetch_related:
+                    optimizations.prefetch_related.add(
+                        f"{field_part_1}__{nested_field}"
+                    )
+        else:
+            if field in info.relations:
+                if info.relations[field].to_many:
+                    optimizations.prefetch_related.add(field)
+                else:
+                    optimizations.select_related.add(field)
+                optimizations.only.add(field)
+            elif field in info.fields:
+                optimizations.only.add(field)
+    return optimizations
+
+
+class SetupEagerLoadingMixin:
+    """
+    This mixin allows to use the setup_eager_loading method to optimize the queries.
+    """
+
+    @classmethod
+    def optimize_qs(cls, queryset, context=None):
+        if hasattr(cls, "setup_eager_loading"):
+            queryset = cls.setup_eager_loading(queryset, context=context)
+        return cls.auto_optimize_queryset(queryset, context=context)
+
+    @classmethod
+    def auto_optimize_queryset(cls, queryset, context=None):
+        request = context.get("request", None)
+        if request and request.method == "GET":
+            serializer_fields = cls(context=context).fields.keys()
+            filtered_fields = set()
+            for field in request.query_params.get("fields", "").split(","):
+                filtered_fields.add(field)
+            if len(filtered_fields) == 0:
+                filtered_fields = serializer_fields
+            model = getattr(cls.Meta, "model", None)
+            if not model:
+                return queryset
+            optimizations = recursive_extract_optimizations(
+                filtered_fields, model_meta.get_field_info(model)
+            )
+            if len(optimizations.only) > 0:
+                queryset = queryset.only(*optimizations.only)
+            if len(optimizations.select_related) > 0:
+                queryset = queryset.select_related(*optimizations.select_related)
+            if len(optimizations.prefetch_related) > 0:
+                queryset = queryset.prefetch_related(*optimizations.prefetch_related)
+        return queryset

camomilla/serializers/mixins/ordering.py

@@ -0,0 +1,34 @@
+from django.db.models.aggregates import Max
+from django.db.models.functions import Coalesce
+from camomilla.fields import ORDERING_ACCEPTED_FIELDS
+
+
+class OrderingMixin:
+    """
+    This mixin allows to set the default value of an ordering field to the max value + 1.
+    """
+
+    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

camomilla/serializers/mixins/page.py

@@ -0,0 +1,58 @@
+from rest_framework import serializers
+from camomilla.models import UrlNode
+from camomilla.serializers.validators import UniquePermalinkValidator
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from camomilla.models.page import AbstractPage
+
+
+class AbstractPageMixin(serializers.ModelSerializer):
+    """
+    This mixin is needed to serialize AbstractPage models.
+    It provides permalink validation and some extra fields serialization.
+
+    Use it as a base class for your serializer if you need to serialize custom AbstractPage models.
+    """
+
+    breadcrumbs = serializers.SerializerMethodField()
+    routerlink = serializers.CharField(read_only=True)
+    template_file = serializers.SerializerMethodField()
+
+    def get_template_file(self, instance: "AbstractPage"):
+        return instance.get_template_path()
+
+    def get_breadcrumbs(self, instance: "AbstractPage"):
+        return instance.breadcrumbs
+
+    @property
+    def translation_fields(self):
+        return super().translation_fields + ["permalink"]
+
+    def get_default_field_names(self, *args):
+        from camomilla.serializers.mixins.translation import RemoveTranslationsMixin
+
+        default_fields = super().get_default_field_names(*args)
+        filtered_fields = getattr(self, "filtered_fields", [])
+        if len(filtered_fields) > 0:
+            return filtered_fields
+        if RemoveTranslationsMixin in self.__class__.__bases__:  # noqa: E501
+            return default_fields
+        return list(
+            set(
+                [f for f in default_fields if f != "url_node"]
+                + UrlNode.LANG_PERMALINK_FIELDS
+                + ["permalink"]
+            )
+        )
+
+    def build_field(self, field_name, info, model_class, nested_depth):
+        if field_name in UrlNode.LANG_PERMALINK_FIELDS + ["permalink"]:
+            return serializers.CharField, {
+                "required": False,
+                "allow_blank": True,
+            }
+        return super().build_field(field_name, info, model_class, nested_depth)
+
+    def get_validators(self):
+        return super().get_validators() + [UniquePermalinkValidator()]

camomilla/serializers/mixins/translation.py

@@ -0,0 +1,103 @@
+from functools import cached_property
+from typing import Iterable, List
+from modeltranslation import settings as mt_settings
+from modeltranslation.translator import NotRegistered, translator
+from modeltranslation.utils import build_localized_fieldname
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+from camomilla.utils.getters import pointed_getter
+from camomilla.utils.translation import is_translatable
+from camomilla.utils.translation import nest_to_plain, plain_to_nest
+from camomilla.settings import API_TRANSLATION_ACCESSOR
+
+
+class TranslationsMixin(serializers.ModelSerializer):
+    """
+    This mixin adds support for modeltranslation fields.
+    It automatically nests all translations fields (es. title_en) under a "translations" field.
+
+    This means that, in representation, the serializer will transform:
+    `{"title_en": "Hello", "title_it": "Ciao"}` -> `{"translations": {"en": {"title": "Hello"}, "it": {"title": "Ciao"}}`
+
+    While in deserialization, the serializer will transform:
+    `{"translations": {"en": {"title": "Hello"}, "it": {"title": "Ciao"}}` -> `{"title_en": "Hello", "title_it": "Ciao"}`
+    """
+
+    def _transform_input(self, data):
+        return nest_to_plain(
+            data, self.translation_fields or [], API_TRANSLATION_ACCESSOR
+        )
+
+    def _transform_output(self, data):
+        return plain_to_nest(
+            data, self.translation_fields or [], API_TRANSLATION_ACCESSOR
+        )
+
+    @cached_property
+    def translation_fields(self) -> List[str]:
+        try:
+            return translator.get_options_for_model(self.Meta.model).get_field_names()
+        except NotRegistered:
+            return []
+
+    @property
+    def _writable_fields(self) -> Iterable[serializers.Field]:
+        for field in super()._writable_fields:
+            if field.field_name not in self.translation_fields:
+                yield field
+
+    def to_internal_value(self, data):
+        return super().to_internal_value(self._transform_input(data))
+
+    def to_representation(self, instance):
+        return self._transform_output(super().to_representation(instance))
+
+    def run_validation(self, *args, **kwargs):
+        try:
+            return super().run_validation(*args, **kwargs)
+        except ValidationError as ex:
+            ex.detail.update(self._transform_input(ex.detail))
+            raise ValidationError(detail=ex.detail)
+
+    @property
+    def is_translatable(self):
+        return is_translatable(pointed_getter(self, "Meta.model"))
+
+
+class RemoveTranslationsMixin(serializers.ModelSerializer):
+    """
+    This mixin removes all translations fields (es. title_en) from the serializer.
+    It's useful when you want to create a serializer that doesn't need to include all translations fields.
+
+    If request is passed in context, this serializer becomes aware of the query parameter "included_translations".
+    If the value is "all", all translations fields are included.
+    If the value is a comma separated list of languages (es. "en,it"), only the specified translations fields are included.
+    """
+
+    @cached_property
+    def translation_fields(self):
+        try:
+            return translator.get_options_for_model(self.Meta.model).get_field_names()
+        except NotRegistered:
+            return []
+
+    def get_default_field_names(self, declared_fields, model_info):
+        request = self.context.get("request", False)
+        included_translations = request and request.GET.get(
+            "included_translations", False
+        )
+        if included_translations == "all":
+            return super().get_default_field_names(declared_fields, model_info)
+        elif included_translations is not False:
+            included_translations = included_translations.split(",")
+        else:
+            included_translations = []
+
+        field_names = super().get_default_field_names(declared_fields, model_info)
+        for lang in mt_settings.AVAILABLE_LANGUAGES:
+            if lang not in included_translations:
+                for field in self.translation_fields:
+                    localized_fieldname = build_localized_fieldname(field, lang)
+                    if localized_fieldname in field_names:
+                        field_names.remove(localized_fieldname)
+        return field_names

camomilla/serializers/page.py

@@ -1,14 +1,63 @@
-from ..models import Content, Page
-from .base import BaseTranslatableModelSerializer
+from camomilla.models.page import UrlNode
+from camomilla.serializers.mixins import AbstractPageMixin
+from camomilla.models import Content, Page
+from camomilla.serializers.base import BaseModelSerializer
+from rest_framework import serializers
 
+from camomilla.serializers.utils import (
+    build_standard_model_serializer,
+    get_standard_bases,
+)
 
-class ContentSerializer(BaseTranslatableModelSerializer):
+
+class ContentSerializer(BaseModelSerializer):
     class Meta:
         model = Content
         fields = "__all__"
 
 
-class PageSerializer(BaseTranslatableModelSerializer):
+class PageSerializer(AbstractPageMixin, BaseModelSerializer):
     class Meta:
         model = Page
         fields = "__all__"
+
+
+class BasicUrlNodeSerializer(BaseModelSerializer):
+    is_public = serializers.SerializerMethodField()
+    status = serializers.SerializerMethodField()
+    indexable = serializers.SerializerMethodField()
+
+    class Meta:
+        model = UrlNode
+        fields = ("id", "permalink", "status", "indexable", "is_public")
+
+    def get_is_public(self, instance: UrlNode):
+        return instance.page.is_public
+
+    def get_status(self, instance: UrlNode):
+        return instance.page.status
+
+    def get_indexable(self, instance: UrlNode):
+        return instance.page.indexable
+
+
+class UrlNodeSerializer(BasicUrlNodeSerializer):
+    alternates = serializers.SerializerMethodField()
+
+    def get_alternates(self, instance: UrlNode):
+        return instance.page.alternate_urls()
+
+    def to_representation(self, instance: UrlNode):
+        model_serializer = build_standard_model_serializer(
+            instance.page.__class__,
+            depth=10,
+            bases=(AbstractPageMixin,) + get_standard_bases(),
+        )
+        return {
+            **super().to_representation(instance),
+            **model_serializer(instance.page, context=self.context).data,
+        }
+
+    class Meta:
+        model = UrlNode
+        fields = "__all__"

camomilla/serializers/user.py

@@ -1,9 +1,10 @@
 from django.forms import ValidationError
-from .base import BaseModelSerializer
+from camomilla.serializers.base import BaseModelSerializer
 from django.contrib.auth import get_user_model, password_validation
 from django.contrib.auth.models import Permission
 from rest_framework import serializers
 from django.utils.translation import gettext_lazy as _
+from django.db.models import Q
 
 
 class PermissionSerializer(BaseModelSerializer):
@@ -39,8 +40,9 @@ class UserProfileSerializer(BaseModelSerializer):
     def get_all_permissions(self, instance):
         return PermissionSerializer(
             Permission.objects.filter(
-                group__pk__in=instance.groups.values_list("pk", flat=True)
-            ).union(instance.user_permissions.all()),
+                Q(group__pk__in=instance.groups.values_list("pk", flat=True))
+                | Q(pk__in=instance.user_permissions.values_list("pk", flat=True))
+            ),
             context=self.context,
             many=True,
         ).data
@@ -66,7 +68,6 @@ class UserProfileSerializer(BaseModelSerializer):
 
 
 class UserSerializer(BaseModelSerializer):
-
     id = serializers.IntegerField(read_only=True)
     password = serializers.CharField(
         write_only=True, required=False, allow_null=True, allow_blank=True

camomilla/serializers/utils.py

@@ -0,0 +1,38 @@
+def get_standard_bases() -> tuple:
+    from rest_framework.serializers import ModelSerializer
+    from camomilla.serializers.mixins import (
+        JSONFieldPatchMixin,
+        NestMixin,
+        OrderingMixin,
+        SetupEagerLoadingMixin,
+        FieldsOverrideMixin,
+        FilterFieldsMixin,
+        RemoveTranslationsMixin,
+    )
+
+    return (
+        SetupEagerLoadingMixin,
+        FilterFieldsMixin,
+        NestMixin,
+        FieldsOverrideMixin,
+        JSONFieldPatchMixin,
+        OrderingMixin,
+        RemoveTranslationsMixin,
+        ModelSerializer,
+    )
+
+
+def build_standard_model_serializer(model, depth, bases=None):
+    if bases is None:
+        bases = get_standard_bases()
+    return type(
+        f"{model.__name__}StandardSerializer",
+        bases,
+        {
+            "Meta": type(
+                "Meta",
+                (object,),
+                {"model": model, "depth": depth, "fields": "__all__"},
+            )
+        },
+    )

camomilla/serializers/validators.py

@@ -0,0 +1,51 @@
+from django.utils.translation import gettext_lazy as _
+from modeltranslation.utils import build_localized_fieldname
+from rest_framework.exceptions import ValidationError
+
+from camomilla.models.page import UrlNode
+from camomilla.utils import activate_languages, is_page
+from camomilla.utils.translation import get_nofallbacks, set_nofallbacks
+
+
+class UniquePermalinkValidator:
+    message = _("There is an other page with same permalink.")
+
+    requires_context = True
+
+    def __call__(self, value, serializer):
+        if not is_page(serializer.Meta.model):
+            return
+        errors = {}
+        instance = serializer.instance
+        exclude_kwargs = {}
+        if instance and instance.url_node:
+            exclude_kwargs["pk"] = instance.url_node.pk
+        parent_page_field = getattr(
+            getattr(serializer.Meta.model, "PageMeta", object),
+            "parent_page_field",
+            "parent_page",
+        )
+        parent_page = value.get(parent_page_field, None) or getattr(
+            instance, parent_page_field, None
+        )
+        for language in activate_languages():
+            autopermalink_f = build_localized_fieldname("autopermalink", language)
+            f_name = build_localized_fieldname("permalink", language)
+            permalink = value.get(
+                f_name, instance and get_nofallbacks(instance, "permalink")
+            )
+            permalink = UrlNode.sanitize_permalink(permalink)
+            autopermalink = value.get(
+                autopermalink_f, instance and get_nofallbacks(instance, "autopermalink")
+            )
+            if autopermalink:
+                continue
+            fake_instance = serializer.Meta.model()
+            set_nofallbacks(fake_instance, "permalink", permalink)
+            if parent_page:
+                set_nofallbacks(fake_instance, parent_page_field, parent_page)
+            qs = UrlNode.objects.exclude(**exclude_kwargs)
+            if qs.filter(permalink=permalink).exists():
+                errors[f_name] = self.message
+        if len(errors.keys()):
+            raise ValidationError(errors)

camomilla/settings.py

@@ -0,0 +1,118 @@
+from django.conf import settings as django_settings
+from modeltranslation.settings import ENABLE_REGISTRATIONS, AVAILABLE_LANGUAGES
+
+from camomilla.utils.getters import pointed_getter
+
+PROJECT_TITLE = pointed_getter(
+    django_settings,
+    "CAMOMILLA.PROJECT_TITLE",
+    pointed_getter(django_settings, "CAMOMILLA_PROJECT_TITLE", "Camomilla"),
+)
+
+THUMBNAIL_FOLDER = pointed_getter(
+    django_settings,
+    "CAMOMILLA.MEDIA.THUMBNAIL.FOLDER",
+    pointed_getter(django_settings, "CAMOMILLA_THUMBTHUMBNAIL_FOLDER", "thumbnails"),
+)
+THUMBNAIL_WIDTH = pointed_getter(
+    django_settings,
+    "CAMOMILLA.MEDIA.THUMBNAIL.WIDTH",
+    pointed_getter(django_settings, "CAMOMILLA_THUMBNAIL_WIDTH", 50),
+)
+THUMBNAIL_HEIGHT = pointed_getter(
+    django_settings,
+    "CAMOMILLA.MEDIA.THUMBNAIL.HEIGHT",
+    pointed_getter(django_settings, "CAMOMILLA_THUMBNAIL_HEIGHT", 50),
+)
+BASE_URL = pointed_getter(
+    django_settings,
+    "CAMOMILLA.ROUTER.BASE_URL",
+    pointed_getter(django_settings, "FORCE_SCRIPT_NAME", None),
+)
+BASE_URL = BASE_URL and "/" + BASE_URL.strip("/")
+
+
+ARTICLE_DEFAULT_TEMPLATE = pointed_getter(
+    django_settings,
+    "CAMOMILLA.RENDER.ARTICLE.DEFAULT_TEMPLATE",
+    "defaults/articles/default.html",
+)
+PAGE_DEFAULT_TEMPLATE = pointed_getter(
+    django_settings,
+    "CAMOMILLA.RENDER.PAGE.DEFAULT_TEMPLATE",
+    "defaults/pages/default.html",
+)
+ARTICLE_INJECT_CONTEXT_FUNC = pointed_getter(
+    django_settings, "CAMOMILLA.RENDER.ARTICLE.INJECT_CONTEXT", None
+)
+PAGE_INJECT_CONTEXT_FUNC = pointed_getter(
+    django_settings, "CAMOMILLA.RENDER.PAGE.INJECT_CONTEXT", None
+)
+
+ENABLE_TRANSLATIONS = (
+    ENABLE_REGISTRATIONS and "modeltranslation" in django_settings.INSTALLED_APPS
+)
+
+DEFAULT_LANGUAGE = pointed_getter(django_settings, "LANGUAGE_CODE", "en")
+
+LANGUAGE_CODES = AVAILABLE_LANGUAGES
+
+MEDIA_OPTIMIZE_MAX_WIDTH = pointed_getter(
+    django_settings, "CAMOMILLA.MEDIA.OPTIMIZE.MAX_WIDTH", 1980
+)
+MEDIA_OPTIMIZE_MAX_HEIGHT = pointed_getter(
+    django_settings, "CAMOMILLA.MEDIA.OPTIMIZE.MAX_HEIGHT", 1400
+)
+MEDIA_OPTIMIZE_DPI = pointed_getter(django_settings, "CAMOMILLA.MEDIA.OPTIMIZE.DPI", 30)
+
+MEDIA_OPTIMIZE_JPEG_QUALITY = pointed_getter(
+    django_settings, "CAMOMILLA.MEDIA.OPTIMIZE.JPEG_QUALITY", 85
+)
+
+ENABLE_MEDIA_OPTIMIZATION = pointed_getter(
+    django_settings, "CAMOMILLA.MEDIA.OPTIMIZE.ENABLE", True
+)
+
+API_NESTING_DEPTH = pointed_getter(django_settings, "CAMOMILLA.API.NESTING_DEPTH", 10)
+
+AUTO_CREATE_HOMEPAGE = pointed_getter(
+    django_settings, "CAMOMILLA.RENDER.AUTO_CREATE_HOMEPAGE", True
+)
+
+TEMPLATE_CONTEXT_FILES = pointed_getter(
+    django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
+)
+
+API_TRANSLATION_ACCESSOR = pointed_getter(
+    django_settings, "CAMOMILLA.API.TRANSLATION_ACCESSOR", "translations"
+)
+
+REGISTERED_TEMPLATES_APPS = pointed_getter(
+    django_settings, "CAMOMILLA.RENDER.REGISTERED_TEMPLATES_APPS", None
+)
+
+DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
+
+# camomilla settings example
+# CAMOMILLA = {
+#     "PROJECT_TITLE": "",
+#     "ROUTER": {
+#         "BASE_URL": ""
+#     },
+#     "MEDIA": {
+#         "OPTIMIZE": {"MAX_WIDTH": 1980, "MAX_HEIGHT": 1400, "DPI": 30, "JPEG_QUALITY": 85, "ENABLE": True},
+#         "THUMBNAIL": {"FOLDER": "", "WIDTH": 50, "HEIGHT": 50}
+#     },
+#     "RENDER": {
+#         "TEMPLATE_CONTEXT_FILES": [],
+#         "AUTO_CREATE_HOMEPAGE": True,
+#         "ARTICLE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None },
+#         "PAGE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None }
+#         "REGISTERED_TEMPLATE_APPS": []
+#     },
+#     "STRUCTURED_FIELD": {
+#         "CACHE_ENABLED": True
+#     }
+#     "API": {"NESTING_DEPTH": 10, "TRANSLATION_ACCESSOR": "translations"},
+#     "DEBUG": False
+# }

camomilla/sitemap.py

@@ -0,0 +1,30 @@
+from django.contrib.sitemaps import Sitemap
+from camomilla.models import UrlNode
+
+
+class CamomillaPagesSitemap(Sitemap):
+    changefreq_default = "daily"
+    priority_default = 0.5
+
+    def changefreq(self, obj):
+        if hasattr(obj.page.__class__, "changefreq"):
+            return obj.page.changefreq
+        return self.changefreq_default
+
+    def priority(self, obj):
+        if hasattr(obj.page.__class__, "priority"):
+            return obj.priority
+        return self.priority_default
+
+    def items(self):
+        return UrlNode.objects.filter(is_public=True)
+
+    def lastmod(self, obj):
+        if hasattr(obj.page.__class__, "lastmod"):
+            return obj.page.lastmod
+        return obj.date_updated_at
+
+
+camomilla_sitemaps = {
+    "pages": CamomillaPagesSitemap,
+}

camomilla/storages/__init__.py

@@ -0,0 +1,4 @@
+from .optimize import OptimizedStorage
+from .overwrite import OverwriteStorage
+
+__all__ = ["OptimizedStorage", "OverwriteStorage"]

camomilla/storages/default.py

@@ -0,0 +1,12 @@
+from django.utils.module_loading import import_string
+from django.conf import settings
+
+from django import VERSION as DJANGO_VERSION
+
+
+def get_default_storage_class():
+    if DJANGO_VERSION >= (4, 2):
+        storage = settings.STORAGES["default"]["BACKEND"]
+    else:
+        storage = settings.DEFAULT_FILE_STORAGE
+    return import_string(storage)