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

camomilla/utils/setters.py

@@ -0,0 +1,37 @@
+from typing import Sequence
+from .getters import pointed_getter
+
+
+def set_key(data, key, val):
+    if isinstance(data, Sequence):
+        key = int(key)
+        if key < len(data):
+            data[key] = val
+        else:
+            data.append(val)
+        return data
+    elif isinstance(data, dict):
+        data[key] = val
+    else:
+        setattr(data, key, val)
+    return data
+
+
+def get_key(data, key, default):
+    if isinstance(data, Sequence):
+        try:
+            return data[int(key)]
+        except IndexError:
+            return default
+    return pointed_getter(data, key, default)
+
+
+def pointed_setter(data, path, value):
+    path = path.split(".")
+    key = path.pop(0)
+    if not len(path):
+        return set_key(data, key, value)
+    default = [] if path[0].isdigit() else {}
+    return set_key(
+        data, key, pointed_setter(get_key(data, key, default), ".".join(path), value)
+    )

camomilla/utils/templates.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+from typing import Sequence
+
+from django import template as django_template
+from os.path import relpath
+from camomilla.settings import REGISTERED_TEMPLATES_APPS
+
+
+def get_all_templates_files() -> Sequence[str]:
+    files = []
+
+    for engine in django_template.loader.engines.all():
+
+        if REGISTERED_TEMPLATES_APPS:
+            dirs = [
+                d
+                for d in engine.template_dirs
+                if any(app in str(d) for app in REGISTERED_TEMPLATES_APPS)
+            ]
+        else:
+            # Exclude pip installed site package template dirs
+            dirs = [
+                d
+                for d in engine.template_dirs
+                if "site-packages" not in str(d) or "camomilla" in str(d)
+            ]
+
+        for d in dirs:
+            base = Path(d)
+            files.extend(relpath(f, d) for f in base.rglob("*.html"))
+
+    return files

camomilla/utils/translation.py

@@ -0,0 +1,114 @@
+import re
+from typing import Any, Sequence, Iterator, Union, List
+
+from django.db.models import Model, Q
+from django.utils.translation.trans_real import activate, get_language
+from modeltranslation.settings import AVAILABLE_LANGUAGES, DEFAULT_LANGUAGE
+from modeltranslation.utils import build_localized_fieldname
+from camomilla.settings import BASE_URL
+from django.http import QueryDict
+
+
+def activate_languages(languages: Sequence[str] = AVAILABLE_LANGUAGES) -> Iterator[str]:
+    old = get_language()
+    for language in languages:
+        activate(language)
+        yield language
+    activate(old)
+
+
+def set_nofallbacks(instance: Model, attr: str, value: Any, **kwargs) -> None:
+    language = kwargs.pop("language", get_language())
+    local_fieldname = build_localized_fieldname(attr, language)
+    if hasattr(instance, local_fieldname):
+        attr = local_fieldname
+    return setattr(instance, attr, value)
+
+
+def get_nofallbacks(instance: Model, attr: str, *args, **kwargs) -> Any:
+    language = kwargs.pop("language", get_language())
+    local_fieldname = build_localized_fieldname(attr, language)
+    if hasattr(instance, local_fieldname):
+        attr = local_fieldname
+    return getattr(instance, attr, *args, **kwargs)
+
+
+def url_lang_decompose(url):
+    if BASE_URL and url.startswith(BASE_URL):
+        url = url[len(BASE_URL) :]
+    data = {"url": url, "permalink": url, "language": DEFAULT_LANGUAGE}
+    result = re.match(rf"^/?({'|'.join(AVAILABLE_LANGUAGES)})?/(.*)", url)  # noqa: W605
+    groups = result and result.groups()
+    if groups and len(groups) == 2:
+        data["language"] = groups[0]
+        data["permalink"] = "/%s" % groups[1]
+    return data
+
+
+def get_field_translations(instance: Model, field_name: str, *args, **kwargs):
+    return {
+        lang: get_nofallbacks(instance, field_name, language=lang, *args, **kwargs)
+        for lang in AVAILABLE_LANGUAGES
+    }
+
+
+def lang_fallback_query(**kwargs):
+    current_lang = get_language()
+    query = Q()
+    for lang in AVAILABLE_LANGUAGES:
+        query |= Q(**{f"{key}_{lang}": value for key, value in kwargs.items()})
+    if current_lang:
+        query = query & Q(
+            **{f"{key}_{current_lang}__isnull": True for key in kwargs.keys()}
+        )
+        query |= Q(**{f"{key}_{current_lang}": value for key, value in kwargs.items()})
+    return query
+
+
+def is_translatable(model: Model) -> bool:
+    from modeltranslation.translator import translator
+
+    return model in translator.get_registered_models()
+
+
+def plain_to_nest(data, fields, accessor="translations"):
+    """
+    This function transforms a plain dictionary with translations fields (es. {"title_en": "Hello"})
+    into a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}}).
+    """
+    trans_data = {}
+    for lang in AVAILABLE_LANGUAGES:
+        lang_data = {}
+        for field in fields:
+            trans_field_name = build_localized_fieldname(field, lang)
+            if trans_field_name in data:
+                lang_data[field] = data.pop(trans_field_name)
+        if lang_data.keys():
+            trans_data[lang] = lang_data
+    if trans_data.keys():
+        data[accessor] = trans_data
+    return data
+
+
+def nest_to_plain(
+    data: Union[dict, QueryDict], fields: List[str], accessor="translations"
+):
+    """
+    This function is the inverse of plain_to_nest.
+    It transforms a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}})
+    into a plain dictionary with translations fields (es. {"title_en": "Hello"}).
+    """
+    if isinstance(data, QueryDict):
+        data = data.dict()
+    translations = data.pop(accessor, {})
+    for lang in AVAILABLE_LANGUAGES:
+        nest_trans = translations.pop(lang, {})
+        for k in fields:
+            data.pop(k, None)  # this removes all trans field without lang
+            if k in nest_trans:
+                # this saves on the default field the default language value
+                if lang == DEFAULT_LANGUAGE:
+                    data[k] = nest_trans[k]
+                key = build_localized_fieldname(k, lang)
+                data[key] = data.get(key, nest_trans[k])
+    return data

camomilla/views/__init__.py

@@ -1,8 +1,8 @@
 from .articles import *
-from .categories import *
 from .contents import *
 from .languages import *
 from .medias import *
 from .pages import *
 from .tags import *
 from .users import *
+from .menus import *

camomilla/views/articles.py

@@ -1,13 +1,11 @@
-from .base import BaseModelViewset
-from .mixins import GetUserLanguageMixin, BulkDeleteMixin
-
-from ..models import Article
-from ..serializers import ArticleSerializer
-from ..permissions import CamomillaBasePermissions
+from camomilla.models import Article
+from camomilla.permissions import CamomillaBasePermissions
+from camomilla.serializers import ArticleSerializer
+from camomilla.views.base import BaseModelViewset
+from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
 
 
 class ArticleViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
-
     queryset = Article.objects.all()
     serializer_class = ArticleSerializer
     permission_classes = (CamomillaBasePermissions,)

camomilla/views/base/__init__.py

@@ -1,8 +1,38 @@
-from ..mixins import OptimViewMixin, PaginateStackMixin, OrderingMixin
+from ..mixins import (
+    OptimViewMixin,
+    PaginateStackMixin,
+    OrderingMixin,
+    CamomillaBasePermissionMixin,
+)
 from rest_framework import viewsets
+from rest_framework.metadata import SimpleMetadata
+from structured.contrib.restframework import StructuredJSONField
 
 
-class BaseModelViewset(
-    OptimViewMixin, OrderingMixin, PaginateStackMixin, viewsets.ModelViewSet
-):
-    pass
+base_viewset_classes = [
+    CamomillaBasePermissionMixin,
+    OptimViewMixin,
+    OrderingMixin,
+    PaginateStackMixin,
+    viewsets.ModelViewSet,
+]
+
+
+class BaseViewMetadata(SimpleMetadata):
+
+    def get_field_info(self, field):
+        field_info = super().get_field_info(field)
+        if isinstance(field, StructuredJSONField):
+            field_info["schema"] = field.schema.json_schema()
+            field_info["type"] = "structured-json"
+        return field_info
+
+    def get_serializer_info(self, serializer):
+        info = super().get_serializer_info(serializer)
+        if hasattr(serializer, "plain_to_nest"):
+            info.update(serializer.plain_to_nest(info))
+        return info
+
+
+class BaseModelViewset(*base_viewset_classes):
+    metadata_class = BaseViewMetadata

camomilla/views/contents.py

@@ -1,18 +1,16 @@
-from .base import BaseModelViewset
 import json
 
 from django.http import JsonResponse
-from django.utils.translation import get_language
 from rest_framework.decorators import action
 
-from ..models import Content
-from ..permissions import CamomillaBasePermissions
-from ..serializers import ContentSerializer
-from .mixins import BulkDeleteMixin, GetUserLanguageMixin
+from camomilla.models import Content
+from camomilla.permissions import CamomillaBasePermissions
+from camomilla.serializers import ContentSerializer
+from camomilla.views.base import BaseModelViewset
+from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
 
 
 class ContentViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
-
     queryset = Content.objects.all()
     serializer_class = ContentSerializer
     model = Content
@@ -20,13 +18,10 @@ class ContentViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
 
     @action(detail=True, methods=["get", "patch"])
     def djsuperadmin(self, request, pk):
-        # content, _ = Content.objects.get_or_create(pk=pk)
-        # content.translate(get_language())
         try:
-            content = Content.objects.language(get_language()).get(pk=pk)
+            content = Content.objects.get(pk=pk)
         except Content.DoesNotExist:
             content, _ = Content.objects.get_or_create(pk=pk)
-            content.translate(get_language())
         if request.method == "GET":
             return JsonResponse({"content": content.content})
         if request.method == "PATCH":

camomilla/views/decorators.py

@@ -0,0 +1,26 @@
+import functools
+from django.utils.translation import activate
+from django.conf import settings
+
+
+def active_lang(*args, **kwargs):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapped_func(*args, **kwargs):
+            if len(args) and hasattr(args[0], "request"):
+                request = args[0].request
+            else:
+                request = args[0] if len(args) else kwargs.get("request", None)
+            lang = settings.LANGUAGE_CODE
+            if request and hasattr(request, "GET"):
+                lang = request.GET.get("lang", request.GET.get("language", lang))
+            if request and hasattr(request, "data"):
+                lang = request.data.pop("lang", request.data.pop("language", lang))
+            if lang and lang in [lng[0] for lng in settings.LANGUAGES]:
+                activate(lang)
+                request.LANGUAGE_CODE = lang
+            return func(*args, **kwargs)
+
+        return wrapped_func
+
+    return decorator

camomilla/views/medias.py

@@ -1,14 +1,20 @@
-from .base import BaseModelViewset
-from .mixins import BulkDeleteMixin, GetUserLanguageMixin, TrigramSearchMixin
-from ..parsers import MultipartJsonParser
-from ..permissions import CamomillaBasePermissions
-
-
-from rest_framework.response import Response
 from rest_framework.parsers import JSONParser
+from rest_framework.response import Response
 
-from ..models import Media, MediaFolder
-from ..serializers import MediaSerializer, MediaFolderSerializer, MediaListSerializer
+from camomilla.models import Media, MediaFolder
+from camomilla.parsers import MultipartJsonParser
+from camomilla.permissions import CamomillaBasePermissions
+from camomilla.serializers import (
+    MediaFolderSerializer,
+    MediaListSerializer,
+    MediaSerializer,
+)
+from camomilla.views.base import BaseModelViewset
+from camomilla.views.mixins import (
+    BulkDeleteMixin,
+    GetUserLanguageMixin,
+    TrigramSearchMixin,
+)
 
 
 class ParseMimeMixin(object):
@@ -29,7 +35,7 @@ class MediaFolderViewSet(
     serializer_class = MediaFolderSerializer
     permission_classes = (CamomillaBasePermissions,)
     items_per_page = 18
-    search_fields = ["name", "title", "alt_text"]
+    search_fields = ["title", "alt_text", "file"]
 
     def get_queryset(self):
         return self.model.objects.all()
@@ -38,24 +44,24 @@ class MediaFolderViewSet(
         return {**super().get_serializer_context(), "action": "list"}
 
     def get_mixed_response(self, request, *args, **kwargs):
-        updir = kwargs.get("pk", None)
+        search = self.request.GET.get("search", None)
+        all = self.request.GET.get("all", "false").lower() == "true"
+        updir = None if all else kwargs.get("pk", None)
+        if not search and all:
+            self.search_fields = []
 
         parent_folder = MediaFolderSerializer(
             self.model.objects.filter(pk=updir).first()
         ).data
-        folder_queryset = self.model.objects.language(self.active_language).fallbacks().filter(updir__pk=updir)
-        media_queryset = (
-            Media.objects.language(self.active_language).fallbacks()
-            if request.GET.get("search", None)
-            else Media.objects.all()
-        ).filter(folder__pk=updir)
+        folder_queryset = self.model.objects.filter(updir__pk=updir)
+        media_queryset = Media.objects.filter(**({} if all else {"folder__pk": updir}))
 
         folder_data = MediaFolderSerializer(
             folder_queryset, many=True, context={"request": request}
         ).data
         media_data = self.format_output(
             *self.handle_pagination_stack(media_queryset),
-            SerializerClass=MediaListSerializer
+            SerializerClass=MediaListSerializer,
         )
         return {
             "folders": folder_data,
@@ -77,7 +83,6 @@ class MediaViewSet(
     TrigramSearchMixin,
     BaseModelViewset,
 ):
-
     queryset = Media.objects.all()
     serializer_class = MediaSerializer
     permission_classes = (CamomillaBasePermissions,)

camomilla/views/menus.py

@@ -0,0 +1,81 @@
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from django.http import Http404
+from django.shortcuts import get_object_or_404
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from camomilla.models import AbstractPage, Menu
+from camomilla.models.page import UrlNode
+from camomilla.permissions import CamomillaBasePermissions
+from camomilla.serializers import ContentTypeSerializer, MenuSerializer
+from camomilla.serializers.page import BasicUrlNodeSerializer
+from camomilla.views.base import BaseModelViewset
+from camomilla.views.decorators import active_lang
+
+
+class MenuViewSet(BaseModelViewset):
+    queryset = Menu.objects.all()
+    serializer_class = MenuSerializer
+    permission_classes = (CamomillaBasePermissions,)
+    model = Menu
+
+    lookup_field = "key"
+
+    def get_object(self):
+        queryset = self.filter_queryset(self.get_queryset())
+        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
+        assert lookup_url_kwarg in self.kwargs, (
+            "Expected view %s to be called with a URL keyword argument "
+            'named "%s". Fix your URL conf, or set the `.lookup_field` '
+            "attribute on the view correctly."
+            % (self.__class__.__name__, lookup_url_kwarg)
+        )
+        filter = Q(**{self.lookup_field: self.kwargs[lookup_url_kwarg]})
+        if (
+            isinstance(self.kwargs[lookup_url_kwarg], str)
+            and self.kwargs[lookup_url_kwarg].isnumeric()
+            or isinstance(self.kwargs[lookup_url_kwarg], int)
+        ):
+            filter |= Q(pk=self.kwargs[lookup_url_kwarg])
+
+        obj = get_object_or_404(queryset, filter)
+        # May raise a permission denied
+        self.check_object_permissions(self.request, obj)
+
+        return obj
+
+    @action(detail=False, methods=["get"], url_path="page_types")
+    def page_types(self, request, *args, **kwargs):
+        return Response(
+            ContentTypeSerializer(
+                [
+                    model
+                    for model in ContentType.objects.all()
+                    if model.model_class()
+                    and issubclass(model.model_class(), AbstractPage)
+                ],
+                many=True,
+            ).data
+        )
+
+    @action(detail=False, methods=["get"], url_path=r"page_types/(?P<content_id>\w+)")
+    def page_type_instances(self, request, content_id, *args, **kwargs):
+        content_type = ContentType.objects.filter(pk=content_id).first()
+        if not content_type or not issubclass(content_type.model_class(), AbstractPage):
+            raise Http404("No object matches the given query.")
+        return Response(
+            [
+                {"id": obj.pk, "name": str(obj), "url_node_id": obj.url_node.pk}
+                for obj in content_type.model_class().objects.exclude(
+                    url_node__isnull=True
+                )
+            ]
+        )
+
+    @active_lang()
+    @action(detail=False, methods=["get"], url_path="search_urlnode")
+    def search_urlnode(self, request, *args, **kwargs):
+        url_node = request.GET.get("q", "")
+        qs = UrlNode.objects.filter(permalink__icontains=url_node).order_by("permalink")
+        return Response(BasicUrlNodeSerializer(qs, many=True).data)

camomilla/views/mixins/__init__.py

@@ -1,73 +1,17 @@
-from rest_framework import status
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from .pagination import *
-from .ordering import *
-from ...permissions import CamomillaBasePermissions
-from django.utils import translation
-
-
-class GetUserLanguageMixin(object):
-    def _get_user_language(self, request):
-        self.active_language = request.GET.get(
-            "language",
-            request.GET.get(
-                "language_code", translation.get_language_from_request(request)
-            ),
-        )
-        self.language_fallbacks = True
-        if (
-            len(self.active_language.split("-")) == 2
-            and self.active_language.split("-")[0] == "nofallbacks"
-        ):
-            self.language_fallbacks = False
-            self.active_language = self.active_language.split("-")[1]
-        translation.activate(self.active_language)
-        return self.active_language
-
-    def initialize_request(self, request, *args, **kwargs):
-        self._get_user_language(request)
-        return super().initialize_request(request, *args, **kwargs)
-
-    def get_queryset(self):
-        return (
-            self.model.objects.language(self.active_language).fallbacks().all()
-            if self.language_fallbacks
-            else self.model.objects.language(self.active_language).all()
-        )
-
-
-class OptimViewMixin:
-    def get_serializer_class(self):
-        if hasattr(self, "action_serializers"):
-            if self.action in self.action_serializers:
-                return self.action_serializers[self.action]
-        return super().get_serializer_class()
-
-    def get_serializer_context(self):
-        return {"request": self.request, "action": self.action}
-
-    def get_queryset(self):
-        queryset = super().get_queryset()
-        serializer = self.get_serializer_class()
-        if hasattr(serializer, "setup_eager_loading"):
-            queryset = self.get_serializer_class().setup_eager_loading(queryset)
-        return queryset
-
-
-class BulkDeleteMixin(object):
-    @action(
-        detail=False, methods=["post"], permission_classes=(CamomillaBasePermissions,)
-    )
-    def bulk_delete(self, request):
-        try:
-            self.model.objects.filter(pk__in=request.data).delete()
-            return Response(
-                {"detail": "Eliminazione multipla andata a buon fine"},
-                status=status.HTTP_200_OK,
-            )
-        except Exception:
-            return Response(
-                {"detail": "Eliminazione multipla non riuscita"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
+from .bulk_actions import BulkDeleteMixin
+from .language import GetUserLanguageMixin
+from .optimize import OptimViewMixin
+from .ordering import OrderingMixin
+from .pagination import PaginateStackMixin, TrigramSearchMixin
+from .permissions import CamomillaBasePermissionMixin
+
+
+__all__ = [
+    "BulkDeleteMixin",
+    "GetUserLanguageMixin",
+    "OptimViewMixin",
+    "OrderingMixin",
+    "PaginateStackMixin",
+    "TrigramSearchMixin",
+    "CamomillaBasePermissionMixin",
+]

camomilla/views/mixins/bulk_actions.py

@@ -0,0 +1,22 @@
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from ...permissions import CamomillaBasePermissions
+
+
+class BulkDeleteMixin(object):
+    @action(
+        detail=False, methods=["post"], permission_classes=(CamomillaBasePermissions,)
+    )
+    def bulk_delete(self, request):
+        try:
+            self.model.objects.filter(pk__in=request.data).delete()
+            return Response(
+                {"detail": "Eliminazione multipla andata a buon fine"},
+                status=status.HTTP_200_OK,
+            )
+        except Exception:
+            return Response(
+                {"detail": "Eliminazione multipla non riuscita"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

camomilla/views/mixins/language.py

@@ -0,0 +1,33 @@
+from django.utils import translation
+from camomilla import settings
+
+
+class GetUserLanguageMixin:
+    def _get_user_language(self, request):
+        active_language_from_request = translation.get_language_from_request(request)
+        active_language = (
+            active_language_from_request
+            if active_language_from_request
+            else settings.DEFAULT_LANGUAGE
+        )
+        active_language = request.GET.get("language_code", active_language)
+        active_language = request.GET.get("language", active_language)
+        self.active_language = active_language
+        self.language_fallbacks = True
+        if (
+            len(self.active_language.split("-")) == 2
+            and self.active_language.split("-")[0] == "nofallbacks"
+        ):
+            self.language_fallbacks = False
+            self.active_language = self.active_language.split("-")[1]
+        translation.activate(self.active_language)
+        return self.active_language
+
+    def initialize_request(self, request, *args, **kwargs):
+        self._get_user_language(request)
+        return super().initialize_request(request, *args, **kwargs)
+
+    def get_queryset(self):
+        if hasattr(super(), "get_queryset"):
+            return super().get_queryset()
+        return self.model.objects.all()

camomilla/views/mixins/optimize.py

@@ -0,0 +1,18 @@
+class OptimViewMixin:
+    def get_serializer_class(self):
+        if hasattr(self, "action_serializers"):
+            if self.action in self.action_serializers:
+                return self.action_serializers[self.action]
+        return super().get_serializer_class()
+
+    def get_serializer_context(self):
+        return {"request": self.request, "action": self.action}
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        serializer = self.get_serializer_class()
+        if hasattr(serializer, "optimize_qs"):
+            queryset = serializer.optimize_qs(
+                queryset, context=self.get_serializer_context()
+            )
+        return queryset

camomilla/views/mixins/ordering.py

@@ -1,12 +1,12 @@
 from rest_framework.decorators import action
 from rest_framework.response import Response
-from ...permissions import CamomillaBasePermissions
+from camomilla.permissions import CamomillaBasePermissions
 from django.core.exceptions import ImproperlyConfigured
 from django.db import transaction, router
 from django.db.models.signals import post_save, pre_save
 from itertools import chain
 from django.db.models.expressions import F
-from ...fields import ORDERING_ACCEPTED_FIELDS
+from camomilla.fields import ORDERING_ACCEPTED_FIELDS
 
 
 class OrderingMixin: