django-camomilla-cms 6.0.0b3__tar.gz → 6.0.0b4__tar.gz

{django-camomilla-cms-6.0.0b3/django_camomilla_cms.egg-info → django-camomilla-cms-6.0.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-camomilla-cms
-Version: 6.0.0b3
+Version: 6.0.0b4
 Summary: Django powered cms
 Home-page: https://github.com/lotrekagency/camomilla
 Author: Lotrèk

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "6.0.0-beta.3"
+__version__ = "6.0.0-beta.4"
 
 
 def get_core_apps():

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/contrib/rest_framework/serializer.py

@@ -77,3 +77,33 @@ class TranslationsMixin(serializers.ModelSerializer):
     @property
     def is_translatable(self):
         return is_translatable(pointed_getter(self, "Meta.model"))
+
+
+class RemoveTranslationsMixin(serializers.ModelSerializer):
+    @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

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/models/page.py

@@ -98,14 +98,18 @@ class UrlNode(models.Model):
     def page(self) -> "AbstractPage":
         return getattr(self, self.related_name)
 
-    @property
-    def routerlink(self) -> str:
+    @staticmethod
+    def reverse_url(permalink: str) -> str:
         try:
-            if self.permalink == "/":
+            if permalink == "/":
                 return reverse("camomilla-homepage")
-            return reverse("camomilla-permalink", args=(self.permalink.lstrip("/"),))
+            return reverse("camomilla-permalink", args=(permalink.lstrip("/"),))
         except NoReverseMatch:
-            return self.permalink
+            return None
+
+    @property
+    def routerlink(self) -> str:
+        return self.reverse_url(self.permalink) or self.permalink
 
 
 PAGE_CHILD_RELATED_NAME = "%(app_label)s_%(class)s_child_pages"
@@ -306,7 +310,10 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
                 bases += (cls.DoesNotExist,)
             message = "%s matching query does not exist." % cls._meta.object_name
             if public_error:
-                message = "Match found: %s.\nThe page appears not to be public.\nUse ?preview=true in the url to see it." % page
+                message = (
+                    "Match found: %s.\nThe page appears not to be public.\nUse ?preview=true in the url to see it."
+                    % page
+                )
             raise type("PageDoesNotExist", bases, {})(message)
         return page
 
@@ -338,7 +345,11 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
             raise Http404(ex)
 
     def alternate_urls(self, *args, **kwargs) -> dict:
-        return get_field_translations(self.url_node or object, "permalink", None)
+        permalinks = get_field_translations(self.url_node or object, "permalink", None)
+        for lang in activate_languages():
+            if lang in permalinks:
+                permalinks[lang] = UrlNode.reverse_url(permalinks[lang])
+        return permalinks
 
     class Meta:
         abstract = True

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/serializers/mixins/__init__.py

@@ -20,6 +20,9 @@ if django.VERSION >= (4, 0):
 else:
     from django.contrib.postgres.fields import JSONField as DjangoJSONField
 
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from camomilla.models.page import AbstractPage
 
 # TODO: decide what to do with LangInfoMixin mixin!
 class LangInfoMixin(metaclass=serializers.SerializerMetaclass):
@@ -122,6 +125,16 @@ class NestMixin:
 
 
 class AbstractPageMixin(serializers.ModelSerializer):
+    breadcrumbs = serializers.SerializerMethodField()
+    routerlink = serializers.CharField(read_only=True)
+    template = serializers.SerializerMethodField()
+    
+    def get_template(self, instance: 'AbstractPage'):
+        return instance.get_template_path()
+    
+    def get_breadcrumbs(self, instance: 'AbstractPage'):
+        return instance.breadcrumbs
+    
     LANG_PERMALINK_FIELDS = [
         build_localized_fieldname("permalink", lang)
         for lang in AVAILABLE_LANGUAGES
@@ -133,6 +146,9 @@ class AbstractPageMixin(serializers.ModelSerializer):
         return super().translation_fields + ["permalink"]
 
     def get_default_field_names(self, *args):
+        from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
+        if RemoveTranslationsMixin in self.__class__.__bases__:  # noqa: E501
+            return super().get_default_field_names(*args)
         return (
             [f for f in super().get_default_field_names(*args) if f != "url_node"]
             + self.LANG_PERMALINK_FIELDS

django-camomilla-cms-6.0.0b4/camomilla/serializers/page.py

@@ -0,0 +1,63 @@
+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(BaseModelSerializer):
+    class Meta:
+        model = Content
+        fields = "__all__"
+
+
+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__"

django-camomilla-cms-6.0.0b4/camomilla/serializers/utils.py

@@ -0,0 +1,35 @@
+def get_standard_bases() -> tuple:
+    from rest_framework.serializers import ModelSerializer
+    from camomilla.serializers.fields import FieldsOverrideMixin
+    from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
+    from camomilla.serializers.mixins import (
+        JSONFieldPatchMixin,
+        NestMixin,
+        OrderingMixin,
+        SetupEagerLoadingMixin,
+    )
+
+    return (
+        NestMixin,
+        FieldsOverrideMixin,
+        JSONFieldPatchMixin,
+        OrderingMixin,
+        RemoveTranslationsMixin,
+        SetupEagerLoadingMixin,
+        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__"},
+            )
+        },
+    )

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/settings.py

@@ -75,6 +75,10 @@ TEMPLATE_CONTEXT_FILES = pointed_getter(
     django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
 )
 
+STRUCTURED_FIELD_CACHE_ENABLED = pointed_getter(
+    django_settings, "CAMOMILLA.STRUCTURED_FIELD.CACHE_ENABLED", True
+)
+
 DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
 
 # camomilla settings example
@@ -93,6 +97,9 @@ DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG
 #         "ARTICLE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None },
 #         "PAGE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None }
 #     },
+#     "STRUCTURED_FIELD": {
+#         "CACHE_ENABLED": True
+#     }
 #     "API": {"NESTING_DEPTH": 10 },
 #     "DEBUG": False
 # }

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/structured/cache.py

@@ -2,6 +2,7 @@ from collections import defaultdict
 from inspect import isclass
 from typing import Any, Dict, Sequence
 from typing_extensions import get_args, get_origin
+from camomilla.settings import STRUCTURED_FIELD_CACHE_ENABLED
 from camomilla.structured.fields import ForeignKey, QuerySet
 from camomilla.structured.models import BaseModel
 from camomilla.structured.utils import _LazyType, get_type, pointed_setter
@@ -161,6 +162,8 @@ class CacheBuilder:
         return fk_data
 
     def inject_cache(self, data: Any) -> Any:
+        if not STRUCTURED_FIELD_CACHE_ENABLED:
+            return data
         fk_data = self.get_all_fk_data(data)
         plainset = defaultdict(set)
         for model, touples in fk_data.items():

django-camomilla-cms-6.0.0b4/camomilla/theme/__init__.py

@@ -0,0 +1 @@
+__version__ = "6.0.0-beta.4"

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/urls.py

@@ -20,6 +20,7 @@ from camomilla.views import (
     UserViewSet,
     MenuViewSet,
 )
+from camomilla.views.pages import fetch_page
 
 router = routers.DefaultRouter()
 
@@ -36,6 +37,8 @@ router.register(r"menus", MenuViewSet, "camomilla-menus")
 
 urlpatterns = [
     path("", include(router.urls)),
+    path("pages-router/", fetch_page),
+    path("pages-router/<path:permalink>", fetch_page),
     path(
         "profiles/me/", lambda _: redirect("../../users/current/"), name="profiles-me"
     ),

django-camomilla-cms-6.0.0b4/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 [l[0] for l in settings.LANGUAGES]:
+                activate(lang)
+                request.LANGUAGE_CODE = lang
+            return func(*args, **kwargs)
+
+        return wrapped_func
+
+    return decorator

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/camomilla/views/menus.py

@@ -1,13 +1,19 @@
 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
 
+from django.utils.translation import get_language
 
 class MenuViewSet(BaseModelViewset):
     queryset = Menu.objects.all()
@@ -15,6 +21,31 @@ class MenuViewSet(BaseModelViewset):
     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(
@@ -42,3 +73,14 @@ class MenuViewSet(BaseModelViewset):
                 )
             ]
         )
+
+    @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")
+        print(get_language())
+        return Response(BasicUrlNodeSerializer(qs, many=True).data)
+        
+        
+        

django-camomilla-cms-6.0.0b4/camomilla/views/pages.py

@@ -0,0 +1,25 @@
+from camomilla.models import Page
+from camomilla.models.page import UrlNode
+from camomilla.permissions import CamomillaBasePermissions
+from camomilla.serializers import PageSerializer
+from camomilla.serializers.page import UrlNodeSerializer
+from camomilla.views.base import BaseModelViewset
+from camomilla.views.decorators import active_lang
+from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from django.shortcuts import get_object_or_404
+
+
+class PageViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
+    queryset = Page.objects.all()
+    serializer_class = PageSerializer
+    permission_classes = (CamomillaBasePermissions,)
+    model = Page
+
+
+@active_lang()
+@api_view(["GET"])
+def fetch_page(request, permalink=""):
+    node = get_object_or_404(UrlNode, permalink=f"/{permalink}")
+    return Response(UrlNodeSerializer(node, context={"request": request}).data)

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4/django_camomilla_cms.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-camomilla-cms
-Version: 6.0.0b3
+Version: 6.0.0b4
 Summary: Django powered cms
 Home-page: https://github.com/lotrekagency/camomilla
 Author: Lotrèk

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/django_camomilla_cms.egg-info/SOURCES.txt

@@ -85,6 +85,7 @@ camomilla/utils/translation.py
 camomilla/views/__init__.py
 camomilla/views/articles.py
 camomilla/views/contents.py
+camomilla/views/decorators.py
 camomilla/views/languages.py
 camomilla/views/medias.py
 camomilla/views/menus.py

{django-camomilla-cms-6.0.0b3 → django-camomilla-cms-6.0.0b4}/setup.py

@@ -1,5 +1,5 @@
 from setuptools import setup
 
-__version__ = "6.0.0-beta.3"
+__version__ = "6.0.0-beta.4"
 
 setup(version=__version__)

django-camomilla-cms-6.0.0b3/camomilla/serializers/page.py

@@ -1,15 +0,0 @@
-from camomilla.serializers.mixins import AbstractPageMixin
-from camomilla.models import Content, Page
-from camomilla.serializers.base import BaseModelSerializer
-
-
-class ContentSerializer(BaseModelSerializer):
-    class Meta:
-        model = Content
-        fields = "__all__"
-
-
-class PageSerializer(AbstractPageMixin, BaseModelSerializer):
-    class Meta:
-        model = Page
-        fields = "__all__"

django-camomilla-cms-6.0.0b3/camomilla/serializers/utils.py

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

django-camomilla-cms-6.0.0b3/camomilla/theme/__init__.py

@@ -1 +0,0 @@
-__version__ = "6.0.0-beta.3"

django-camomilla-cms-6.0.0b3/camomilla/views/pages.py

@@ -1,12 +0,0 @@
-from camomilla.models import Page
-from camomilla.permissions import CamomillaBasePermissions
-from camomilla.serializers import PageSerializer
-from camomilla.views.base import BaseModelViewset
-from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
-
-
-class PageViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
-    queryset = Page.objects.all()
-    serializer_class = PageSerializer
-    permission_classes = (CamomillaBasePermissions,)
-    model = Page