django-camomilla-cms 6.0.1__tar.gz → 6.1.1__tar.gz

{django_camomilla_cms-6.0.1/django_camomilla_cms.egg-info → django_camomilla_cms-6.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-camomilla-cms
-Version: 6.0.1
+Version: 6.1.1
 Summary: Django powered cms
 Author-email: Lotrèk <dimmitutto@lotrek.it>
 License: MIT

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "6.0.1"
+__version__ = "6.1.1"
 
 
 def get_core_apps():

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/models/menu.py

@@ -74,7 +74,7 @@ class MenuNode(BaseModel):
 
 
 class Menu(models.Model):
-    key = models.CharField(max_length=200, unique=True, editable=False)
+    key = models.CharField(max_length=200, unique=True, editable=True, default=uuid4)
     available_classes = models.JSONField(default=dict, editable=False)
     enabled = models.BooleanField(default=True)
     nodes = StructuredJSONField(default=list, schema=MenuNode)

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/models/page.py

@@ -29,6 +29,7 @@ from camomilla import settings
 from camomilla.templates_context.rendering import ctx_registry
 from django.conf import settings as django_settings
 from modeltranslation.utils import build_localized_fieldname
+from django.utils.module_loading import import_string
 
 
 class UrlRedirect(models.Model):
@@ -287,6 +288,22 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
                 context.update(new_ctx)
         return ctx_registry.get_context_for_page(self, request, super_ctx=context)
 
+    @classmethod
+    def get_serializer(cls):
+        from camomilla.serializers.mixins import AbstractPageMixin
+
+        standard_serializer = (
+            pointed_getter(cls, "_page_meta.standard_serializer")
+            or settings.PAGES_DEFAULT_SERIALIZER
+        )
+        if isinstance(standard_serializer, str):
+            standard_serializer = import_string(standard_serializer)
+        if not issubclass(standard_serializer, AbstractPageMixin):
+            raise ValueError(
+                f"Standard serializer {standard_serializer} must be a subclass of AbstractPageMixin"
+            )
+        return standard_serializer
+
     @property
     def model_name(self) -> str:
         return self._meta.app_label + "." + self._meta.model_name
@@ -326,7 +343,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def childs(self) -> models.Manager:
         if hasattr(self._page_meta, "child_page_field"):
             return getattr(self, self._page_meta.child_page_field)
-        return getattr(self, PAGE_CHILD_RELATED_NAME % self.model_info)
+        return getattr(self, PAGE_CHILD_RELATED_NAME % self.model_info, self.__class__.objects.none())
 
     @property
     def parent(self) -> models.Model:
@@ -356,7 +373,8 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def generate_permalink(self, safe: bool = True) -> str:
         permalink = f"/{slugify(self.title or '', allow_unicode=True)}"
         if self.parent:
-            permalink = f"/{self.parent.permalink}{permalink}"
+            parent_permalink = (self.parent.permalink or "").lstrip("/")
+            permalink = f"/{parent_permalink}{permalink}"
         set_nofallbacks(self, "permalink", permalink)
         qs = UrlNode.objects.exclude(pk=getattr(self.url_node or object, "pk", None))
         if safe and qs.filter(permalink=permalink).exists():
@@ -455,7 +473,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         preview = request and getattr(request, "GET", {}).get("preview", False)
         permalinks = get_field_translations(self.url_node or object, "permalink", None)
         for lang in activate_languages():
-            if lang in permalinks:
+            if lang in permalinks and permalinks[lang]:
                 permalinks[lang] = (
                     UrlNode.reverse_url(permalinks[lang])
                     if preview or self.is_public
@@ -475,6 +493,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         parent_page_field = "parent_page"
         default_template = settings.PAGE_DEFAULT_TEMPLATE
         inject_context_func = settings.PAGE_INJECT_CONTEXT_FUNC
+        standard_serializer = settings.PAGES_DEFAULT_SERIALIZER
 
 
 class Page(AbstractPage):

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/serializers/page.py

@@ -22,7 +22,7 @@ class PageSerializer(AbstractPageMixin, BaseModelSerializer):
         fields = "__all__"
 
 
-class BasicUrlNodeSerializer(BaseModelSerializer):
+class UrlNodeSerializer(BaseModelSerializer):
     is_public = serializers.SerializerMethodField()
     status = serializers.SerializerMethodField()
     indexable = serializers.SerializerMethodField()
@@ -41,17 +41,18 @@ class BasicUrlNodeSerializer(BaseModelSerializer):
         return instance.page.indexable
 
 
-class UrlNodeSerializer(BasicUrlNodeSerializer):
+class RouteSerializer(UrlNodeSerializer):
     alternates = serializers.SerializerMethodField()
 
     def get_alternates(self, instance: UrlNode):
         return instance.page.alternate_urls()
 
     def to_representation(self, instance: UrlNode):
+        standard_serializer = instance.page.get_serializer()
         model_serializer = build_standard_model_serializer(
             instance.page.__class__,
             depth=10,
-            bases=(AbstractPageMixin,) + get_standard_bases(),
+            bases=(standard_serializer,) + get_standard_bases(),
         )
         return {
             **super().to_representation(instance),

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/settings.py

@@ -49,6 +49,12 @@ PAGE_INJECT_CONTEXT_FUNC = pointed_getter(
     django_settings, "CAMOMILLA.RENDER.PAGE.INJECT_CONTEXT", None
 )
 
+PAGES_DEFAULT_SERIALIZER = pointed_getter(
+    django_settings,
+    "CAMOMILLA.API.PAGES.DEFAULT_SERIALIZER",
+    "camomilla.serializers.mixins.AbstractPageMixin",
+)
+
 ENABLE_TRANSLATIONS = (
     ENABLE_REGISTRATIONS and "modeltranslation" in django_settings.INSTALLED_APPS
 )
@@ -127,6 +133,6 @@ DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG
 #             "URL": "http://localhost:4321"
 #         }
 #     }
-#     "API": {"NESTING_DEPTH": 10, "TRANSLATION_ACCESSOR": "translations"},
+#     "API": {"NESTING_DEPTH": 10, "TRANSLATION_ACCESSOR": "translations", "PAGES": {"DEFAULT_SERIALIZER": "camomilla.serializers.page.RouteSerializer"}},
 #     "DEBUG": False
 # }

django_camomilla_cms-6.1.1/camomilla/theme/__init__.py

@@ -0,0 +1 @@
+__version__ = "6.1.1"

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/urls.py

@@ -19,7 +19,7 @@ from camomilla.views import (
     UserViewSet,
     MenuViewSet,
 )
-from camomilla.views.pages import fetch_page
+from camomilla.views.pages import pages_router
 from camomilla.redirects import url_patterns as old_redirects
 
 router = routers.DefaultRouter()
@@ -37,8 +37,8 @@ router.register(r"menus", MenuViewSet, "camomilla-menus")
 urlpatterns = [
     *old_redirects,
     path("", include(router.urls)),
-    path("pages-router/", fetch_page),
-    path("pages-router/<path:permalink>", fetch_page),
+    path("pages-router/", pages_router),
+    path("pages-router/<path:permalink>", pages_router),
     path("token-auth/", CamomillaObtainAuthToken.as_view(), name="api_token"),
     path("auth/login/", CamomillaAuthLogin.as_view(), name="login"),
     path("auth/logout/", CamomillaAuthLogout.as_view(), name="logout"),

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/views/menus.py

@@ -9,7 +9,7 @@ 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.serializers.page import UrlNodeSerializer
 from camomilla.views.base import BaseModelViewset
 from camomilla.views.decorators import active_lang
 
@@ -66,7 +66,12 @@ class MenuViewSet(BaseModelViewset):
             raise Http404("No object matches the given query.")
         return Response(
             [
-                {"id": obj.pk, "name": str(obj), "url_node_id": obj.url_node.pk}
+                {
+                    "id": obj.pk,
+                    "name": str(obj),
+                    "url_node_id": obj.url_node.pk,
+                    "model": f"{content_type.app_label}.{content_type.model}",
+                }
                 for obj in content_type.model_class().objects.exclude(
                     url_node__isnull=True
                 )
@@ -78,4 +83,4 @@ class MenuViewSet(BaseModelViewset):
     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)
+        return Response(UrlNodeSerializer(qs, many=True).data)

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/camomilla/views/pages.py

@@ -2,7 +2,7 @@ from camomilla.models import Page
 from camomilla.models.page import UrlNode, UrlRedirect
 from camomilla.permissions import CamomillaBasePermissions
 from camomilla.serializers import PageSerializer
-from camomilla.serializers.page import UrlNodeSerializer
+from camomilla.serializers.page import RouteSerializer
 from camomilla.views.base import BaseModelViewset
 from camomilla.views.decorators import active_lang
 from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
@@ -26,10 +26,10 @@ class PageViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
         permissions.AllowAny,
     ]
 )
-def fetch_page(request, permalink=""):
+def pages_router(request, permalink=""):
     redirect = UrlRedirect.find_redirect_from_url(f"/{permalink}")
     if redirect:
         redirect = redirect.redirect()
         return Response({"redirect": redirect.url, "status": redirect.status_code})
-    node = get_object_or_404(UrlNode, permalink=f"/{permalink}")
-    return Response(UrlNodeSerializer(node, context={"request": request}).data)
+    node: UrlNode = get_object_or_404(UrlNode, permalink=f"/{permalink}")
+    return Response(RouteSerializer(node, context={"request": request}).data)

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1/django_camomilla_cms.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-camomilla-cms
-Version: 6.0.1
+Version: 6.1.1
 Summary: Django powered cms
 Author-email: Lotrèk <dimmitutto@lotrek.it>
 License: MIT

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/django_camomilla_cms.egg-info/SOURCES.txt

@@ -129,6 +129,8 @@ tests/test_model_api.py
 tests/test_model_api_permissions.py
 tests/test_model_api_register.py
 tests/test_models.py
+tests/test_page_meta.py
+tests/test_page_relation_api.py
 tests/test_pages.py
 tests/test_query_parser.py
 tests/test_templates_context.py

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/setup.py

@@ -1,5 +1,5 @@
 from setuptools import setup
 
-__version__ = "6.0.1"
+__version__ = "6.1.1"
 
 setup(version=__version__)

django_camomilla_cms-6.1.1/tests/test_page_meta.py

@@ -0,0 +1,88 @@
+import pytest
+from django.test import TestCase
+from rest_framework.test import APIClient
+
+from tests.utils.media import load_asset_and_remove_media
+from .utils.api import login_superuser
+from camomilla.models import Page, Media
+from example.website.models import CustomPageMetaModel, InvalidPageMetaModel
+
+
+class PagaMetaTestCase(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        token = login_superuser()
+        self.client.credentials(HTTP_AUTHORIZATION="Token " + token)
+
+    @pytest.mark.django_db
+    def test_page_meta_rendering(self):
+        asset = load_asset_and_remove_media("37059501.png")
+        Media.objects.create(
+            file=asset,
+            alt_text="Test Media",
+            title="Test Media",
+            description="Description of test media",
+        )
+        page = CustomPageMetaModel.objects.create(
+            title="Test Page",
+            custom_field="Custom Data",
+            permalink="test-page",
+            status="PUB",
+            autopermalink=False,
+        )
+        page.save()
+        response = self.client.get("/test-page/")
+        assert response.status_code == 200
+        content = response.content.decode()
+        assert "👻 I'm beeing injected!" in content
+        assert "<h1>I'm the custom template!</h1>" in content
+        assert "<ul><li>Test Media</li></ul>" in content
+
+    @pytest.mark.django_db
+    def test_page_meta_custom_parent_page(self):
+        parent_page = Page.objects.create(
+            title="Parent Page",
+            permalink="parent-page",
+            status="PUB",
+            autopermalink=False,
+        )
+        child_page = CustomPageMetaModel.objects.create(
+            title="Child Page",
+            custom_field="Child Data",
+            status="PUB",
+            custom_parent_page=parent_page,
+        )
+        assert child_page.permalink == "/parent-page/child-page"
+
+    @pytest.mark.django_db
+    def test_page_meta_custom_serializer(self):
+
+        CustomPageMetaModel.objects.create(
+            title="Test Page with Custom Serializer",
+            custom_field="Custom Data",
+            permalink="test-page-custom-serializer",
+            status="PUB",
+            autopermalink=False,
+        )
+
+        response = self.client.get(
+            "/api/camomilla/pages-router/test-page-custom-serializer"
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["title"] == "Test Page with Custom Serializer"
+        assert data["custom_field"] == "Custom Data"
+        assert data["permalink"] == "/test-page-custom-serializer"
+        assert (
+            data["serializer_custom_field"]
+            == "I'm coming from CustomPageSerializer! 🫡"
+        )
+
+    @pytest.mark.django_db
+    def test_page_meta_custom_serializer_error(self):
+        with pytest.raises(ValueError) as exc_info:
+            InvalidPageMetaModel.get_serializer()
+            assert (
+                str(exc_info.value)
+                == "Standard serializer <class 'example.website.serializers.InvalidSerializer'> must be a subclass of AbstractPageMixin"
+            )

django_camomilla_cms-6.1.1/tests/test_page_relation_api.py

@@ -0,0 +1,77 @@
+from django.test import TestCase
+from rest_framework.test import APIClient
+from .utils.api import login_superuser
+from example.website.models import (
+    ExposedRelatedPageModel,
+    UnexposedRelatedPageModel,
+    RelatedPageModel,
+)
+
+client = APIClient()
+
+
+class PageRelationApi(TestCase):
+    def setUp(self):
+        token = login_superuser()
+        client.credentials(HTTP_AUTHORIZATION="Token " + token)
+
+    def test_exposed_relation(self):
+        exposed_related_page_model = ExposedRelatedPageModel.objects.create(
+            title="ExposedRelatedPageModel 1",
+            permalink="exposed-related-page-model-1",
+            status="PUB",
+            autopermalink=False,
+        )
+        related_page_model = RelatedPageModel.objects.create(
+            title="RelatedPageModel 1",
+            permalink="related-page-model-1",
+            status="PUB",
+            autopermalink=False,
+        )
+        related_page_model.exposed_pages.add(exposed_related_page_model)
+        related_page_model.save()
+
+        response = client.get("/api/camomilla/pages-router/related-page-model-1")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["exposed_pages"][0]["id"] == exposed_related_page_model.id
+
+        response = client.get(
+            "/api/camomilla/pages-router/exposed-related-page-model-1"
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert (
+            "related_pages" in data
+        ), "Exposed related pages should be included in the API response"
+
+    def test_unexposed_relation(self):
+        unexposed_related_page_model = UnexposedRelatedPageModel.objects.create(
+            title="UnexposedRelatedPageModel 1",
+            permalink="unexposed-related-page-model-1",
+            status="PUB",
+            autopermalink=False,
+        )
+        related_page_model = RelatedPageModel.objects.create(
+            title="RelatedPageModel 1",
+            permalink="related-page-model-1",
+            status="PUB",
+            autopermalink=False,
+        )
+
+        related_page_model.unexposed_pages.add(unexposed_related_page_model)
+        related_page_model.save()
+
+        response = client.get("/api/camomilla/pages-router/related-page-model-1")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["unexposed_pages"][0]["id"] == unexposed_related_page_model.id
+
+        response = client.get(
+            "/api/camomilla/pages-router/unexposed-related-page-model-1"
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert (
+            "related_pages" not in data
+        ), "Unexposed related pages should not be included in the API response"

{django_camomilla_cms-6.0.1 → django_camomilla_cms-6.1.1}/tests/test_pages.py

@@ -165,13 +165,11 @@ class PagesTestCase(TestCase):
         # EN parent page with automatic url creation
         response = self.client.get("/api/camomilla/pages/3/?language=en")
         assert response.json()["autopermalink"] == True
-        assert response.json()["permalink"] == "//permalink_manual_en_2/title_page_3"
+        assert response.json()["permalink"] == "/permalink_manual_en_2/title_page_3"
         # IT parent page with automatic url creation
         response = self.client.get("/api/camomilla/pages/3/?language=it")
         assert response.json()["autopermalink"] == True
-        assert (
-            response.json()["permalink"] == "//permalink_manuale_it_2/titolo_pagina_3"
-        )
+        assert response.json()["permalink"] == "/permalink_manuale_it_2/titolo_pagina_3"
 
         # Check url uniqueness and consistency EN
         response = self.client.post(

django_camomilla_cms-6.0.1/camomilla/theme/__init__.py

@@ -1 +0,0 @@
-__version__ = "6.0.1"