django-camomilla-cms 6.0.0b14__py2.py3-none-any.whl → 6.0.0b16__py2.py3-none-any.whl

camomilla/__init__.py

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

camomilla/dynamic_pages_urls.py

@@ -7,7 +7,8 @@ from .models import Page
 
 
 def fetch(request, *args, **kwargs):
-    preview = request.user.is_staff and request.GET.get("preview", False)
+    can_preview = request.user.is_staff or settings.DEBUG
+    preview = can_preview and request.GET.get("preview", False)
     append_slash = getattr(django_settings, "APPEND_SLASH", True)
     if append_slash and not request.path.endswith("/"):
         return redirect(request.path + "/")

camomilla/fields/__init__.py

@@ -1,7 +1,5 @@
 from django.db import models
 
-from camomilla.structured import StructuredJSONField
-
 from .json import ArrayField, JSONField
 
 ORDERING_ACCEPTED_FIELDS = (
@@ -12,4 +10,4 @@ ORDERING_ACCEPTED_FIELDS = (
     models.SmallIntegerField,
 )
 
-__all__ = ["StructuredJSONField", "JSONField", "ArrayField", "ORDERING_ACCEPTED_FIELDS"]
+__all__ = ["JSONField", "ArrayField", "ORDERING_ACCEPTED_FIELDS"]

camomilla/managers/pages.py

@@ -1,42 +1,31 @@
-from typing import Any, Tuple
 from django.db.models.query import QuerySet
-from django.db import transaction
+from django.core.exceptions import ObjectDoesNotExist
 from django.apps import apps
 
 URL_NODE_RELATED_NAME = "%(app_label)s_%(class)s"
 
 
 class PageQuerySet(QuerySet):
-    def get_or_create(self, defaults=None, **kwargs) -> Tuple[Any, bool]:
-        if "permalink" in kwargs and isinstance(kwargs["permalink"], str):
-            if kwargs["permalink"].startswith("/"):
-                kwargs["permalink"] = kwargs["permalink"][1:]
-            with transaction.atomic():
-                UrlNode = apps.get_model("camomilla", "UrlNode")
-                url_node, created = UrlNode.objects.get_or_create(
-                    defaults={
-                        "related_name": URL_NODE_RELATED_NAME
-                        % {
-                            "app_label": self.model._meta.app_label,
-                            "class": self.model._meta.model_name,
-                        }
-                    },
-                    permalink=kwargs["permalink"],
 
+    __UrlNodeModel = None
+
+    @property
+    def UrlNodeModel(self):
+        if not self.__UrlNodeModel:
+            self.__UrlNodeModel = apps.get_model("camomilla", "UrlNode")
+        return self.__UrlNodeModel
+
+    def get_permalink_kwargs(self, kwargs):
+        return list(set(kwargs.keys()).intersection(set(self.UrlNodeModel.LANG_PERMALINK_FIELDS + ["permalink"])))
+
+    def get(self, *args, **kwargs):
+        permalink_args = self.get_permalink_kwargs(kwargs)
+        if len(permalink_args):
+            try:
+                node = self.UrlNodeModel.objects.get(**{arg: kwargs.pop(arg) for arg in permalink_args})
+                kwargs["url_node"] = node
+            except ObjectDoesNotExist:
+                raise self.model.DoesNotExist(
+                    "%s matching query does not exist." % self.model._meta.object_name
                 )
-                if created is False and url_node.page is not None:
-                    page = self.get(**kwargs)
-                    if page.pk != url_node.page.pk:
-                        raise self.model.MultipleObjectsReturned(
-                            "got more than one %s object for the same permalink: %s"
-                            % (
-                                self.model._meta.object_name,
-                                kwargs["permalink"],
-                            )
-                        )
-                    return url_node.page, False
-                kwargs["url_node"] = url_node
-                kwargs["slug"] = kwargs["permalink"]
-                kwargs.pop("permalink")
-                return super().get_or_create(defaults, **kwargs)
-        return super().get_or_create(defaults, **kwargs)
+        return super(PageQuerySet, self).get(*args, **kwargs)

camomilla/model_api.py

@@ -26,6 +26,7 @@ def register(
     """
 
     def inner(model):
+        global urlpatterns
         base_meta = {
             "model": model,
             "fields": "__all__",
@@ -46,14 +47,18 @@ def register(
                 )
             },
         )
+        
+        def get_queryset(self, *args, **kwargs):
+            qs = super(base_viewset, self).get_queryset(*args, **kwargs)
+            return qs if filters is None else qs.filter(**filters)
 
         viewset = type(
             f"{model.__name__}ViewSet",
             (base_viewset,),
             {
-                "get_queryset": lambda self: model.objects.all()
-                if filters is None
-                else model.objects.filter(**filters),
+                "queryset": model.objects.all(),
+                "model": model,
+                "get_queryset": get_queryset,
                 "serializer_class": serializer,
                 **viewset_attrs,
             },
@@ -73,7 +78,7 @@ def register(
             viewset,
             f"{model.__name__.lower()}_api",
         )
-        urlpatterns.append(path("", include(router.urls)))
+        urlpatterns = [path("", include(router.urls))]
         return model
 
     return inner

camomilla/models/media.py

@@ -150,7 +150,7 @@ class Media(models.Model):
                 img_bytes = self.file.storage.open(self.file.name, "rb")
             with Image.open(img_bytes) as orig_image:
                 image = orig_image.copy()
-                image.thumbnail((THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT), Image.ANTIALIAS)
+                image.thumbnail((THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT), Image.LANCZOS)
 
                 # Path to save to, name, and extension
                 thumb_name, thumb_extension = os.path.splitext(self.file.name)

camomilla/models/menu.py

@@ -12,9 +12,12 @@ from pydantic import (
     computed_field,
     model_serializer,
 )
-from camomilla import structured
-from camomilla.models.page import UrlNode
+from structured.pydantic.models import BaseModel
+from structured.fields import StructuredJSONField
+from camomilla.models.page import UrlNode, AbstractPage
 from typing import Optional, Union, Callable, List
+from django.db.models.base import Model as DjangoModel
+from django.conf import settings
 
 
 class LinkTypes(str, Enum):
@@ -22,21 +25,29 @@ class LinkTypes(str, Enum):
     static = "ST"
 
 
-class MenuNodeLink(structured.BaseModel):
+class MenuNodeLink(BaseModel):
     link_type: LinkTypes = LinkTypes.static
     static: str = None
-    content_type: int = None
-    page_id: int = None
+    content_type: ContentType = None
+    page: AbstractPage = 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()
+            if self.content_type and self.page:
+                if isinstance(self.page, DjangoModel) and not self.page._meta.abstract:
+                    self.content_type = ContentType.objects.get_for_model(self.page.__class__)
+                ctype_id = getattr(self.content_type, "pk", self.content_type)
+                page_id = getattr(self.page, "pk", self.page)
+                c_type = ContentType.objects.filter(pk=ctype_id).first()
                 model = c_type and c_type.model_class()
-                page = model and model.objects.filter(pk=self.page_id).first()
+                page = model and model.objects.filter(pk=page_id).first()
                 self.url_node = page and page.url_node
+            elif self.url_node:
+                url_node_id = getattr(self.url_node, "pk", self.url_node)
+                self.page = UrlNode.objects.filter(pk=url_node_id).first().page
+                self.content_type = ContentType.objects.get_for_model(self.page.__class__)
         return handler(self)
 
     def get_url(self, request=None):
@@ -51,7 +62,7 @@ class MenuNodeLink(structured.BaseModel):
         return self.get_url()
 
 
-class MenuNode(structured.BaseModel):
+class MenuNode(BaseModel):
     id: str = Field(default_factory=uuid4)
     meta: dict = {}
     nodes: List["MenuNode"] = []
@@ -63,7 +74,7 @@ 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)
+    nodes = StructuredJSONField(default=list, schema=MenuNode)
 
     class Meta:
         verbose_name = _("menu")
@@ -77,7 +88,8 @@ class Menu(models.Model):
     ):
         if isinstance(context, RequestContext):
             context = context.flatten()
-        context.update({"menu": self})
+        is_preview = bool(request.GET.get("preview", False))
+        context.update({"menu": self, "is_preview": is_preview})
         return mark_safe(render_to_string(template_path, context, request))
 
     class defaultdict(dict):

camomilla/models/page.py

@@ -2,7 +2,6 @@ from typing import Sequence, Tuple
 from uuid import uuid4
 
 from django.core.exceptions import ObjectDoesNotExist
-from django.core.validators import RegexValidator
 
 from django.db import ProgrammingError, OperationalError, models, transaction
 from django.db.models.signals import post_delete
@@ -13,6 +12,7 @@ from django.utils import timezone
 from django.utils.functional import lazy
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
+from django.utils.translation import get_language
 
 from camomilla.managers.pages import PageQuerySet
 from camomilla.models.mixins import MetaMixin, SeoMixin
@@ -29,6 +29,12 @@ from camomilla.utils.getters import pointed_getter
 from camomilla import settings
 from camomilla.templates_context.rendering import ctx_registry
 from django.conf import settings as django_settings
+from modeltranslation.settings import AVAILABLE_LANGUAGES
+from modeltranslation.utils import build_localized_fieldname
+
+
+class UrlPathValidator():
+    pass
 
 
 def GET_TEMPLATE_CHOICES():
@@ -111,6 +117,13 @@ class UrlNodeManager(models.Manager):
 
 
 class UrlNode(models.Model):
+
+    LANG_PERMALINK_FIELDS = [
+        build_localized_fieldname("permalink", lang)
+        for lang in AVAILABLE_LANGUAGES
+        if settings.ENABLE_TRANSLATIONS
+    ]
+
     permalink = models.CharField(max_length=400, unique=True, null=True)
     related_name = models.CharField(max_length=200)
     objects = UrlNodeManager()
@@ -141,6 +154,23 @@ class UrlNode(models.Model):
             return ""
         return self.routerlink
 
+    @staticmethod
+    def sanitize_permalink(permalink):
+        if isinstance(permalink, str):
+            p_parts = permalink.split("/")
+            permalink = "/".join([slugify(p, allow_unicode=True).strip() for p in p_parts])
+            if not permalink.startswith("/"):
+                permalink = f"/{permalink}"
+        return permalink
+
+    def save(self, *args, **kwargs) -> None:
+        for lang_p_field in UrlNode.LANG_PERMALINK_FIELDS:
+            setattr(self, lang_p_field, UrlNode.sanitize_permalink(getattr(self, lang_p_field)))
+        super().save(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return self.permalink
+
 
 PAGE_CHILD_RELATED_NAME = "%(app_label)s_%(class)s_child_pages"
 URL_NODE_RELATED_NAME = "%(app_label)s_%(class)s"
@@ -154,11 +184,29 @@ PAGE_STATUS = (
 
 
 class PageBase(models.base.ModelBase):
+    """
+        This models comes to implement a language based permalink logic
+    """
+    def perm_prop_factory(permalink_field):
+        def getter(_self):
+            return getattr(_self, f"__{permalink_field}", getattr(_self.url_node or object(), permalink_field, None))
+
+        def setter(_self, value: str):
+            setattr(_self, f"__{permalink_field}", value)
+        return getter, setter
+
     def __new__(cls, name, bases, attrs, **kwargs):
         attr_meta = attrs.pop("PageMeta", None)
         new_class = super().__new__(cls, name, bases, attrs, **kwargs)
         page_meta = attr_meta or getattr(new_class, "PageMeta", None)
         base_page_meta = getattr(new_class, "_page_meta", None)
+        for lang_p_field in UrlNode.LANG_PERMALINK_FIELDS:
+            computed_prop = property(*cls.perm_prop_factory(lang_p_field))
+            setattr(new_class, lang_p_field, computed_prop)
+        setattr(new_class, "permalink", property(
+            lambda _self: getattr(_self, build_localized_fieldname("permalink", get_language()), None),
+            lambda _self, value: setattr(_self, f"__{build_localized_fieldname('permalink', get_language())}", value)
+        ))
         if page_meta:
             for name, value in getattr(base_page_meta, "__dict__", {}).items():
                 if name not in page_meta.__dict__:
@@ -167,16 +215,6 @@ class PageBase(models.base.ModelBase):
         return new_class
 
 
-class UrlPathValidator(RegexValidator):
-    
-    regex = r"^[a-zA-Z0-9_\-\/]+[^\/]$"
-    message = _(
-        "Enter a valid 'slug' consisting of lowercase letters, numbers, "
-        "underscores, hyphens and slashes."
-    )
-    flags = 0
-
-
 class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     date_created = models.DateTimeField(auto_now_add=True)
     date_updated_at = models.DateTimeField(auto_now=True)
@@ -188,9 +226,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         editable=False,
     )
     breadcrumbs_title = models.CharField(max_length=128, null=True, blank=True)
-    slug = models.CharField(
-        max_length=150, null=True, blank=True, validators=[UrlPathValidator()]
-    )
+    autopermalink = models.BooleanField(default=True)
     status = models.CharField(
         max_length=3,
         choices=PAGE_STATUS,
@@ -212,6 +248,19 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
 
     objects = PageQuerySet.as_manager()
 
+    __cached_db_instance: "AbstractPage" = None
+
+    @property
+    def db_instance(self):
+        if self.__cached_db_instance is None:
+            self.__cached_db_instance = self.get_db_instance()
+        return self.__cached_db_instance
+
+    def get_db_instance(self):
+        if self.pk:
+            return self.__class__.objects.get(pk=self.pk)
+        return None
+
     def __init__(self, *args, **kwargs):
         super(AbstractPage, self).__init__(*args, **kwargs)
         self._meta.get_field("template").choices = lazy(GET_TEMPLATE_CHOICES, list)()
@@ -240,10 +289,6 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def model_info(self) -> dict:
         return {"app_label": self._meta.app_label, "class": self._meta.model_name}
 
-    @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
@@ -252,7 +297,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def breadcrumbs(self) -> Sequence[dict]:
         breadcrumb = {
             "permalink": self.permalink,
-            "title": self.breadcrumbs_title or self.title or self.slug,
+            "title": self.breadcrumbs_title or self.title or "",
         }
         if self.parent:
             return self.parent.breadcrumbs + [breadcrumb]
@@ -291,8 +336,10 @@ 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():
-            old_permalink = self.permalink
-            new_permalink = self.generate_permalink()
+            old_permalink = self.db_instance and self.db_instance.permalink
+            new_permalink = self.permalink
+            if self.autopermalink:
+                new_permalink = self.generate_permalink()
             force = force or old_permalink != new_permalink
             set_nofallbacks(self.url_node, "permalink", new_permalink)
         if force:
@@ -301,22 +348,10 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         return self.url_node
 
     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()
-            fallback_slug = next((t for t in translations if t is not None), None)
-            slug = (
-                slugify(self.title or uuid4(), allow_unicode=True)
-                if fallback_slug is None
-                else fallback_slug
-            )
-            set_nofallbacks(self, "slug", slug)
-        slug_parts = (slug or "").split("/")
-        for i, part in enumerate(slug_parts):
-            slug_parts[i] = slugify(part, allow_unicode=True)            
-        permalink = "/%s" % "/".join(slug_parts)
+        permalink = f"/{slugify(self.title or '', allow_unicode=True)}"
         if self.parent:
-            permalink = f"{self.parent.permalink}{permalink}"
+            permalink = f"/{self.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():
             permalink = "/".join(
@@ -333,7 +368,10 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def save(self, *args, **kwargs) -> None:
         with transaction.atomic():
             self._update_url_node()
-            return super().save(*args, **kwargs)
+            super().save(*args, **kwargs)
+            self.__cached_db_instance = None
+            for lang_p_field in UrlNode.LANG_PERMALINK_FIELDS:
+                hasattr(self, f"__{lang_p_field}") and delattr(self, f"__{lang_p_field}")
 
     @classmethod
     def get(cls, request, *args, **kwargs) -> "AbstractPage":
@@ -386,7 +424,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
                 node = UrlNode.objects.get(permalink="/")
             return node.page, False
         except UrlNode.DoesNotExist:
-            return cls.get_or_create(None, slug="")
+            return cls.get_or_create(None, permalink="/")
 
     @classmethod
     def get_or_404(cls, request, *args, **kwargs) -> "AbstractPage":

camomilla/openapi/schema.py

@@ -55,4 +55,8 @@ class SchemaGenerator(DRFSchemaGenerator):
     def create_view(self, callback, method, request=None):
         view = super(SchemaGenerator, self).create_view(callback, method, request)
         view.schema = AutoSchema()
+        if not hasattr(view, 'get_queryset') and getattr(view, 'queryset', None) is None:
+            attname = "permission_classes"
+            cname = "DjangoModelPermissions"
+            setattr(view, attname, [p for p in getattr(view, attname, []) if cname not in p.__name__])
         return view

camomilla/serializers/base/__init__.py

@@ -8,14 +8,16 @@ from ..mixins import (
     OrderingMixin,
     SetupEagerLoadingMixin,
 )
+from ..mixins.filter_fields import FilterFieldsMixin
 
 
 class BaseModelSerializer(
+    SetupEagerLoadingMixin,
     NestMixin,
+    FilterFieldsMixin,
     FieldsOverrideMixin,
     JSONFieldPatchMixin,
     OrderingMixin,
-    SetupEagerLoadingMixin,
     TranslationsMixin,
     serializers.ModelSerializer,
 ):

camomilla/serializers/fields/__init__.py

@@ -1,7 +1,7 @@
 from django.db import models
 from rest_framework import serializers
 
-from camomilla import structured
+from structured.fields import StructuredJSONField as ModelStructuredJSONField
 
 from .json import StructuredJSONField
 from .file import FileField, ImageField
@@ -16,6 +16,6 @@ class FieldsOverrideMixin:
         **serializers.ModelSerializer.serializer_field_mapping,
         models.FileField: FileField,
         models.ImageField: ImageField,
-        structured.StructuredJSONField: StructuredJSONField,
+        ModelStructuredJSONField: StructuredJSONField,
     }
     serializer_related_field = RelatedField

camomilla/serializers/fields/json.py

@@ -3,10 +3,10 @@ from rest_framework import serializers
 from rest_framework.utils import model_meta
 from typing import TYPE_CHECKING, Any, Union, Dict, List
 
-from camomilla.structured.utils import pointed_setter
+from camomilla.utils.setters import pointed_setter
 
 if TYPE_CHECKING:
-    from camomilla.structured import BaseModel
+    from structured.pydantic.models import BaseModel
 
 
 class StructuredJSONField(serializers.JSONField):

camomilla/serializers/fields/related.py

@@ -18,6 +18,7 @@ class RelatedField(serializers.PrimaryKeyRelatedField):
     """
 
     def __init__(self, **kwargs):
+        self.inherited_fields_filter = kwargs.pop("inherited_fields_filter", [])
         self.serializer = kwargs.pop("serializer", None)
         self.lookup = kwargs.pop("lookup", "id")
         if self.serializer is not None:
@@ -42,7 +43,10 @@ class RelatedField(serializers.PrimaryKeyRelatedField):
 
     def to_representation(self, instance):
         if self.serializer:
-            return self.serializer(instance, context=self.context).data
+            kwargs = {"context": self.context}
+            if self.inherited_fields_filter:
+                kwargs["inherited_fields_filter"] = self.inherited_fields_filter
+            return self.serializer(instance, **kwargs).data
         return super().to_representation(instance)
 
     def to_internal_value(self, data):

camomilla/serializers/mixins/__init__.py

@@ -3,11 +3,10 @@ from django.conf import settings as django_settings
 from django.db.models.aggregates import Max
 from django.db.models.functions import Coalesce
 from django.utils import translation
-from modeltranslation.settings import AVAILABLE_LANGUAGES
-from modeltranslation.utils import build_localized_fieldname
 from rest_framework import serializers
 from rest_framework.utils import model_meta
 
+from camomilla.models import UrlNode
 from camomilla.fields import ORDERING_ACCEPTED_FIELDS
 from camomilla.serializers.fields.related import RelatedField
 from camomilla.serializers.utils import build_standard_model_serializer
@@ -58,8 +57,50 @@ class SetupEagerLoadingMixin:
     """
     This mixin allows to use the setup_eager_loading method to optimize the queries.
     """
-    @staticmethod
-    def setup_eager_loading(queryset):
+    
+    @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":
+            model = getattr(cls.Meta, "model", None)
+            info = model_meta.get_field_info(model)
+            only = set()
+            prefetch_related = set()
+            select_related = set()
+            serializer_fields = cls(context=context).fields.keys()
+            filtered_fields = set()
+            for field in request.query_params.get("fields", "").split(","):
+                if "__" in field:
+                    field, _ = field.split("__", 1)
+                if field in serializer_fields:
+                    filtered_fields.add(field)
+            if len(filtered_fields) == 0:
+                filtered_fields = serializer_fields
+            for field in filtered_fields:
+                complete_field = field
+                if "__" in field:
+                    field, sub_field = field.split("__", 1)
+                    complete_field = f"{field}__{sub_field}"
+                if field in info.forward_relations and not info.forward_relations[field].to_many:
+                    select_related.add(field)
+                    only.add(complete_field)
+                elif field in info.reverse_relations or field in info.forward_relations and  info.forward_relations[field].to_many:
+                    prefetch_related.add(field)
+                    only.add(complete_field)
+                elif field in info.fields or field == info.pk.name:
+                    only.add(complete_field)
+            if len(only) > 0:
+                queryset = queryset.only(*only)
+            if len(select_related) > 0:
+                queryset = queryset.select_related(*select_related)
+            if len(prefetch_related) > 0:
+                queryset = queryset.prefetch_related(*prefetch_related)
         return queryset
 
 
@@ -169,32 +210,29 @@ class AbstractPageMixin(serializers.ModelSerializer):
     def get_breadcrumbs(self, instance: "AbstractPage"):
         return instance.breadcrumbs
 
-    LANG_PERMALINK_FIELDS = [
-        build_localized_fieldname("permalink", lang)
-        for lang in AVAILABLE_LANGUAGES
-        if settings.ENABLE_TRANSLATIONS
-    ]
-
     @property
     def translation_fields(self):
         return super().translation_fields + ["permalink"]
 
     def get_default_field_names(self, *args):
         from camomilla.contrib.rest_framework.serializer 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 super().get_default_field_names(*args)
+            return default_fields
         return (
-            [f for f in super().get_default_field_names(*args) if f != "url_node"]
-            + self.LANG_PERMALINK_FIELDS
-            + ["permalink"]
+            [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 self.LANG_PERMALINK_FIELDS + ["permalink"]:
+        if field_name in UrlNode.LANG_PERMALINK_FIELDS + ["permalink"]:
             return serializers.CharField, {
-                "source": "url_node.%s" % field_name,
-                "read_only": True,
+                "required": False,
+                "allow_blank": True,
             }
         return super().build_field(field_name, info, model_class, nested_depth)