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

{django-camomilla-cms-6.0.0b2/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.0b2
+Version: 6.0.0b4
 Summary: Django powered cms
 Home-page: https://github.com/lotrekagency/camomilla
 Author: Lotrèk

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

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

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/apps.py

@@ -3,6 +3,8 @@ from __future__ import unicode_literals
 from django.apps import AppConfig
 from django.conf import settings
 
+from camomilla.context.autodiscover import autodiscover_context_files
+
 
 class CamomillaConfig(AppConfig):
     default_auto_field = "django.db.models.AutoField"
@@ -13,3 +15,4 @@ class CamomillaConfig(AppConfig):
         if "camomilla" not in migration_modules:
             migration_modules["camomilla"] = "camomilla_migrations"
         setattr(settings, "MIGRATION_MODULES", migration_modules)
+        autodiscover_context_files()

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/contrib/modeltranslation/hvad_migration.py

@@ -3,7 +3,6 @@ from django.db import migrations, connection
 
 
 class KeepTranslationsMixin:
-
     _saved_data_from_plain = {}
     language_codes = dict(getattr(settings, "LANGUAGES", {})).keys()
 
@@ -30,7 +29,7 @@ class KeepTranslationsMixin:
         for modelPath, fields in self.keep_translations.items():
             Model = apps.get_model(*modelPath.split("."))
             table = Model._meta.db_table + "_translation"
-            if not "language_code" in fields:
+            if "language_code" not in fields:
                 fields = ("language_code",) + fields
             with connection.cursor() as cursor:
                 cursor.execute("SELECT master_id FROM {0};".format(table))

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

@@ -52,7 +52,7 @@ class TranslationsMixin(serializers.ModelSerializer):
     @property
     def _writable_fields(self):
         for field in super()._writable_fields:
-            if not field.field_name in self.translation_fields:
+            if field.field_name not in self.translation_fields:
                 yield field
 
     def to_internal_value(self, data):
@@ -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.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/dynamic_pages_urls.py

@@ -1,13 +1,19 @@
 from django.shortcuts import render
 from django.urls import path
 
+from camomilla import settings
+
 from .models import Page
 
 
 def fetch(request, *args, **kwargs):
     preview = request.user.is_staff and request.GET.get("preview", False)
     if "permalink" in kwargs:
-        page = Page.get_or_404(request, bypass_public_check=preview, bypass_type_check=True)
+        page = Page.get_or_404(
+            request, bypass_public_check=preview, bypass_type_check=True
+        )
+    elif settings.AUTO_CREATE_HOMEPAGE is False:
+        page, _ = Page.get_or_404(permalink="/", bypass_type_check=True)
     else:
         page, _ = Page.get_or_create_homepage()
     return render(request, page.get_template_path(request), page.get_context(request))

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/fields/json.py

@@ -12,15 +12,7 @@ from django.contrib.postgres.fields import ArrayField as DjangoArrayField
 from django.db import models
 
 
-class JSONField(DjangoJSONField):
-    pass
-
-
-class ArrayField(DjangoArrayField):
-    pass
-
-
-if "sqlite" in settings.DATABASES["default"]["ENGINE"]:
+if "sqlite" in settings.DATABASES["default"]["ENGINE"]:  # noqa: C901
 
     class JSONField(models.Field):
         def db_type(self, connection):
@@ -64,3 +56,14 @@ if "sqlite" in settings.DATABASES["default"]["ENGINE"]:
                 }
             )
             return name, path, args, kwargs
+
+else:
+
+    class JSONField(DjangoJSONField):
+        pass
+
+    class ArrayField(DjangoArrayField):
+        pass
+
+
+__all__ = [JSONField, ArrayField]

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/management/commands/regenerate_thumbnails.py

@@ -3,7 +3,6 @@ from camomilla.models import Media
 
 
 class Command(BaseCommand):
-
     help = "Regenerates all the thumbnail"
 
     def handle(self, *args, **options):

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/model_api.py

@@ -13,7 +13,7 @@ def register(
     base_viewset=BaseModelViewset,
     serializer_meta={},
     viewset_attrs={},
-    filters = None
+    filters=None,
 ):
     """
     Register a model to the API.
@@ -30,8 +30,8 @@ def register(
             "model": model,
             "fields": "__all__",
         }
-        if 'exclude' in serializer_meta:
-            base_meta.pop('fields')
+        if "exclude" in serializer_meta:
+            base_meta.pop("fields")
         serializer = type(
             f"{model.__name__}Serializer",
             (base_serializer,),
@@ -51,7 +51,9 @@ def register(
             f"{model.__name__}ViewSet",
             (base_viewset,),
             {
-                "get_queryset": lambda self: model.objects.all() if filters is None else model.objects.filter(**filters),
+                "get_queryset": lambda self: model.objects.all()
+                if filters is None
+                else model.objects.filter(**filters),
                 "serializer_class": serializer,
                 **viewset_attrs,
             },

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

@@ -0,0 +1,5 @@
+from .article import *  # NOQA
+from .content import *  # NOQA
+from .media import *  # NOQA
+from .page import *  # NOQA
+from .menu import *  # NOQA

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/models/article.py

@@ -1,6 +1,5 @@
 from django.conf import settings as dj_settings
 from django.db import models
-from django.utils.translation import gettext_lazy as _
 
 from camomilla.models.page import AbstractPage
 from camomilla import settings

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/models/media.py

@@ -5,7 +5,6 @@ from io import BytesIO
 import magic
 from django.core.exceptions import ValidationError
 from django.core.files.base import ContentFile
-from django.core.files.storage import default_storage as storage
 from django.db import models
 from django.db.models.fields.related import ForeignObjectRel
 from django.db.models.signals import post_save, pre_delete
@@ -181,7 +180,7 @@ class Media(models.Model):
     def _get_file_size(self):
         try:
             return self.file.storage.size(self.file.name)
-        except:
+        except Exception:
             return 0
 
     def __str__(self):

django-camomilla-cms-6.0.0b4/camomilla/models/menu.py

@@ -0,0 +1,89 @@
+from enum import Enum
+from uuid import uuid4
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django.template.loader import render_to_string
+from django.template import RequestContext
+from django.utils.safestring import mark_safe
+from pydantic import (
+    Field,
+    SerializationInfo,
+    computed_field,
+    model_serializer,
+)
+from camomilla import structured
+from camomilla.models.page import UrlNode
+from typing import Optional, Union, Callable
+
+
+class LinkTypes(str, Enum):
+    relational = "RE"
+    static = "ST"
+
+
+class MenuNodeLink(structured.BaseModel):
+    link_type: LinkTypes = LinkTypes.static
+    static: str = None
+    content_type: int = None
+    page_id: int = None
+    url_node: UrlNode = None
+
+    @model_serializer(mode="wrap", when_used="json")
+    def update_relational(self, handler: Callable, info: SerializationInfo):
+        if self.link_type == LinkTypes.relational:
+            if self.content_type and self.page_id:
+                c_type = ContentType.objects.filter(pk=self.content_type).first()
+                model = c_type and c_type.model_class()
+                page = model and model.objects.filter(pk=self.page_id).first()
+                self.url_node = page and page.url_node
+        return handler(self)
+
+    def get_url(self, request=None):
+        if self.link_type == LinkTypes.relational:
+            return isinstance(self.url_node, UrlNode) and self.url_node.routerlink
+        elif self.link_type == LinkTypes.static:
+            return self.static
+
+    @computed_field
+    @property
+    def url(self) -> Optional[str]:
+        return self.get_url()
+
+
+class MenuNode(structured.BaseModel):
+    id: str = Field(default_factory=uuid4)
+    meta: dict = {}
+    nodes: list["MenuNode"] = []
+    title: str = ""
+    link: MenuNodeLink
+
+
+class Menu(models.Model):
+    key = models.CharField(max_length=200, unique=True, editable=False)
+    available_classes = models.JSONField(default=dict, editable=False)
+    enabled = models.BooleanField(default=True)
+    nodes = structured.StructuredJSONField(default=list, schema=MenuNode)
+
+    class Meta:
+        verbose_name = _("menu")
+        verbose_name_plural = _("menus")
+
+    def render(
+        self,
+        template_path: str,
+        request=None,
+        context: Union[dict, RequestContext] = {},
+    ):
+        if isinstance(context, RequestContext):
+            context = context.flatten()
+        context.update({"menu": self})
+        return mark_safe(render_to_string(template_path, context, request))
+
+    class defaultdict(dict):
+        def __missing__(self, key):
+            dict.__setitem__(self, key, Menu.objects.get_or_create(key=key)[0])
+            return self[key]
+
+    def __str__(self) -> str:
+        return self.key

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/models/mixins/__init__.py

@@ -2,7 +2,6 @@ from django.db import models
 
 
 class SeoMixin(models.Model):
-
     title = models.CharField(max_length=200, null=True, blank=True)
     description = models.TextField(null=True, blank=True)
     og_description = models.TextField(blank=True, null=True)

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

@@ -1,4 +1,4 @@
-from typing import Iterable, Tuple
+from typing import Sequence, Tuple
 from uuid import uuid4
 
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +20,15 @@ from camomilla.utils import (
     lang_fallback_query,
     set_nofallbacks,
     url_lang_decompose,
-    get_all_templates_files
+    get_all_templates_files,
 )
 from camomilla.utils.getters import pointed_getter
 from camomilla import settings
+from camomilla.context.rendering import ctx_registry
+
 
 def GET_TEMPLATE_CHOICES():
-    return [(t,t)for t in get_all_templates_files()]
+    return [(t, t) for t in get_all_templates_files()]
 
 
 class UrlNodeManager(models.Manager):
@@ -42,7 +44,7 @@ class UrlNodeManager(models.Manager):
     def _annotate_fields(
         self,
         qs: models.QuerySet,
-        field_names: Iterable[Tuple[str, models.Field, models.Value]],
+        field_names: Sequence[Tuple[str, models.Field, models.Value]],
     ):
         for field_name, output_field, default in field_names:
             whens = [
@@ -66,9 +68,21 @@ class UrlNodeManager(models.Manager):
             return self._annotate_fields(
                 super().get_queryset(),
                 [
-                    ("indexable", models.BooleanField(), models.Value(None, models.BooleanField())),
-                    ("status", models.BooleanField(), models.Value(None, models.BooleanField())),
-                    ("pubblication_date", models.DateTimeField(), models.Value(timezone.now(), models.DateTimeField())),
+                    (
+                        "indexable",
+                        models.BooleanField(),
+                        models.Value(None, models.BooleanField()),
+                    ),
+                    (
+                        "status",
+                        models.BooleanField(),
+                        models.Value(None, models.BooleanField()),
+                    ),
+                    (
+                        "pubblication_date",
+                        models.DateTimeField(),
+                        models.Value(timezone.now(), models.DateTimeField()),
+                    ),
                 ],
             )
         except (ProgrammingError, OperationalError):
@@ -83,15 +97,19 @@ class UrlNode(models.Model):
     @property
     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 == '/':
-                return reverse('camomilla-homepage')
-            return reverse('camomilla-permalink', args=(self.permalink.lstrip("/"),))
+            if permalink == "/":
+                return reverse("camomilla-homepage")
+            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"
@@ -123,7 +141,11 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     date_created = models.DateTimeField(auto_now_add=True)
     date_updated_at = models.DateTimeField(auto_now=True)
     url_node = models.OneToOneField(
-        UrlNode, on_delete=models.CASCADE, related_name=URL_NODE_RELATED_NAME, null=True, editable=False
+        UrlNode,
+        on_delete=models.CASCADE,
+        related_name=URL_NODE_RELATED_NAME,
+        null=True,
+        editable=False,
     )
     breadcrumbs_title = models.CharField(max_length=128, null=True, blank=True)
     slug = models.SlugField(max_length=150, allow_unicode=True, null=True, blank=True)
@@ -145,16 +167,16 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         blank=True,
         on_delete=models.CASCADE,
     )
-    
+
     def __init__(self, *args, **kwargs):
         super(AbstractPage, self).__init__(*args, **kwargs)
-        self._meta.get_field('template').choices = lazy(GET_TEMPLATE_CHOICES,list)()
+        self._meta.get_field("template").choices = lazy(GET_TEMPLATE_CHOICES, list)()
 
     def __str__(self) -> str:
         return "(%s) %s" % (self.__class__.__name__, self.title or self.permalink)
 
     def get_context(self, request=None):
-        context={
+        context = {
             "page": self,
             "page_model": {"class": self.__class__.__name__, "module": self.__module__},
             "request": request,
@@ -164,7 +186,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
             new_ctx = inject_func(request=request, super_ctx=context)
             if isinstance(new_ctx, dict):
                 context.update(new_ctx)
-        return context
+        return ctx_registry.get_context_for_page(self, request, super_ctx=context)
 
     @property
     def model_name(self) -> str:
@@ -177,13 +199,13 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     @property
     def permalink(self) -> str:
         return self.url_node and self.url_node.permalink
-    
+
     @property
     def routerlink(self) -> str:
         return self.url_node and self.url_node.routerlink
-        
+
     @property
-    def breadcrumbs(self) -> Iterable[dict]:
+    def breadcrumbs(self) -> Sequence[dict]:
         breadcrumb = {
             "permalink": self.permalink,
             "title": self.breadcrumbs_title or self.title or self.slug,
@@ -197,7 +219,9 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         if self.status == "PUB":
             return True
         if self.status == "PLA":
-            return bool(self.pubblication_date) and timezone.now() > self.pubblication_date
+            return (
+                bool(self.pubblication_date) and timezone.now() > self.pubblication_date
+            )
         return False
 
     def get_template_path(self, request=None) -> str:
@@ -222,7 +246,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
 
     def _update_url_node(self, force: bool = False) -> UrlNode:
         self.url_node = self._get_or_create_url_node()
-        for _ in activate_languages():
+        for __ in activate_languages():
             old_permalink = self.permalink
             new_permalink = self.generate_permalink()
             force = force or old_permalink != new_permalink
@@ -232,7 +256,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
             self.update_childs()
         return self.url_node
 
-    def generate_permalink(self, safe:bool=True) -> str:
+    def generate_permalink(self, safe: bool = True) -> str:
         slug = get_nofallbacks(self, "slug")
         if slug is None and not self.permalink:
             translations = get_field_translations(self, "slug").values()
@@ -277,14 +301,20 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
             ).first()
             page = node and node.page
         type_error = not bypass_type_check and not isinstance(page, cls)
-        public_error = not bypass_public_check and not getattr(page or object, "is_public", False)
+        public_error = not bypass_public_check and not getattr(
+            page or object, "is_public", False
+        )
         if not page or type_error or public_error:
             bases = (UrlNode.DoesNotExist,)
             if hasattr(cls, "DoesNotExist"):
                 bases += (cls.DoesNotExist,)
-            raise type("PageDoesNotExist", bases, {})(
-                "%s matching query does not exist." % cls._meta.object_name
-            )
+            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
+                )
+            raise type("PageDoesNotExist", bases, {})(message)
         return page
 
     @classmethod
@@ -311,11 +341,15 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def get_or_404(cls, request, *args, **kwargs) -> "AbstractPage":
         try:
             return cls.get(request, *args, **kwargs)
-        except ObjectDoesNotExist:
-            raise Http404("No %s matches the given query." % cls._meta.object_name)
+        except ObjectDoesNotExist as ex:
+            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.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/openapi/schema.py

@@ -7,9 +7,13 @@ from camomilla.contrib.rest_framework.serializer import (
     plain_to_nest,
     TRANS_ACCESSOR,
 )
+from camomilla.serializers.fields.json import StructuredJSONField
+from camomilla.utils.getters import find_and_replace_dict, pointed_getter
 
 
 class AutoSchema(DRFAutoSchema):
+    extra_components = {}
+
     def map_serializer(self, serializer):
         schema = super(AutoSchema, self).map_serializer(serializer)
         if isinstance(serializer, TranslationsMixin) and serializer.is_translatable:
@@ -23,6 +27,29 @@ class AutoSchema(DRFAutoSchema):
             }
         return schema
 
+    def get_components(self, path, method):
+        components = super().get_components(path, method)
+        if len(self.extra_components.keys()) > 0:
+            components = {**(components or {}), **self.extra_components}
+        return components
+
+    def map_field(self, field):
+        if isinstance(field, StructuredJSONField):
+
+            def replace(key, value):
+                if isinstance(value, str) and value.startswith("#/definitions"):
+                    return value.replace("#/definitions", "#/components/schemas")
+                return value
+
+            self.extra_components.update(
+                **find_and_replace_dict(
+                    field.json_schema.pop("definitions", {}), replace
+                )
+            )
+
+            return find_and_replace_dict(field.json_schema, replace)
+        return super().map_field(field)
+
 
 class SchemaGenerator(DRFSchemaGenerator):
     def create_view(self, callback, method, request=None):

{django-camomilla-cms-6.0.0b2 → django-camomilla-cms-6.0.0b4}/camomilla/parsers.py

@@ -38,7 +38,6 @@ def compile_payload(data, path, value):
 
 
 class MultipartJsonParser(parsers.BaseParser):
-
     media_type = "multipart/form-data"
 
     def parse(self, stream, media_type=None, parser_context=None):

django-camomilla-cms-6.0.0b4/camomilla/serializers/fields/json.py

@@ -0,0 +1,24 @@
+from rest_framework import serializers
+from rest_framework.utils import model_meta
+
+
+class StructuredJSONField(serializers.JSONField):
+    def __init__(self, **kwargs):
+        self.schema = kwargs.pop("schema", None)
+        super().__init__(**kwargs)
+
+    def bind(self, field_name, parent):
+        if self.schema is None and isinstance(parent, serializers.ModelSerializer):
+            info = model_meta.get_field_info(parent.Meta.model)
+            field = info.fields[field_name]
+            self.schema = field.schema
+            self.many = field.many
+            self.json_schema = field.schema.json_schema()
+        super().bind(field_name, parent)
+
+    def to_representation(self, instance):
+        if isinstance(instance, list) and self.many:
+            return super().to_representation(
+                self.schema.dump_python(instance, exclude_unset=True)
+            )
+        return super().to_representation(instance.model_dump(exclude_unset=True))

{django-camomilla-cms-6.0.0b2 → 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):
@@ -121,8 +124,17 @@ class NestMixin:
         return field_class, field_kwargs
 
 
-
 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
@@ -134,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
@@ -150,4 +165,3 @@ class AbstractPageMixin(serializers.ModelSerializer):
 
     def get_validators(self):
         return super().get_validators() + [UniquePermalinkValidator()]
-