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

camomilla/models/page.py

@@ -1,12 +1,13 @@
-from typing import Sequence, Tuple
+from typing import Sequence, Tuple, Optional, Union
 from uuid import uuid4
 
 from django.core.exceptions import ObjectDoesNotExist
 
-from django.db import ProgrammingError, OperationalError, models, transaction
-from django.db.models.signals import post_delete
+from django.db import models, transaction
+from django.db.models.signals import post_delete, post_save, pre_save
 from django.dispatch import receiver
-from django.http import Http404
+from django.http import Http404, HttpRequest
+from django.shortcuts import redirect
 from django.urls import NoReverseMatch, reverse
 from django.utils import timezone
 from django.utils.functional import lazy
@@ -14,7 +15,7 @@ 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.managers.pages import PageQuerySet, UrlNodeManager
 from camomilla.models.mixins import MetaMixin, SeoMixin
 from camomilla.utils import (
     activate_languages,
@@ -29,100 +30,85 @@ 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():
     return [(t, t) for t in get_all_templates_files()]
 
 
-class UrlNodeManager(models.Manager):
-    @property
-    def related_names(self):
-        self._related_names = getattr(
-            self,
-            "_related_names",
-            super().get_queryset().values_list("related_name", flat=True).distinct(),
-        )
-        return self._related_names
-
-    def _annotate_fields(
-        self,
-        qs: models.QuerySet,
-        field_names: Sequence[Tuple[str, models.Field, models.Value]],
-    ):
-        for field_name, output_field, default in field_names:
-            whens = [
-                models.When(
-                    related_name=related_name,
-                    then=models.F("__".join([related_name, field_name])),
-                )
-                for related_name in self.related_names
-            ]
-            qs = qs.annotate(
-                **{
-                    field_name: models.Case(
-                        *whens, output_field=output_field, default=default
-                    )
-                }
-            )
-        return self._annotate_is_public(qs)
-
-    def _annotate_is_public(self, qs: models.QuerySet):
-        return qs.annotate(
-            is_public=models.Case(
-                models.When(status="PUB", then=True),
-                models.When(
-                    status="PLA", publication_date__lte=timezone.now(), then=True
-                ),
-                default=False,
-                output_field=models.BooleanField(default=False),
-            )
+class UrlRedirect(models.Model):
+    language_code = models.CharField(max_length=10, null=True)
+    from_url = models.CharField(max_length=400)
+    to_url = models.CharField(max_length=400)
+    url_node = models.ForeignKey(
+        "UrlNode", on_delete=models.CASCADE, related_name="redirects"
+    )
+    permanent = models.BooleanField(default=True)
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_updated_at = models.DateTimeField(auto_now=True)
+
+    __q_string = ""
+
+    def __str__(self) -> str:
+        return f"[{self.language_code}] {self.from_url} -> {self.to_url}"
+
+    @classmethod
+    def find_redirect(
+        cls, request: HttpRequest, language_code: Optional[str] = None
+    ) -> Optional["UrlRedirect"]:
+        instance = cls.find_redirect_from_url(request.path, language_code)
+        if instance:
+            instance.__q_string = request.META.get("QUERY_STRING", "")
+        return instance
+
+    @classmethod
+    def find_redirect_from_url(
+        cls, from_url: str, language_code: Optional[str] = None
+    ) -> Optional["UrlRedirect"]:
+        path_decomposition = url_lang_decompose(from_url)
+        language_code = (
+            language_code or path_decomposition["language"] or get_language()
         )
+        from_url = path_decomposition["permalink"]
+        return cls.objects.filter(
+            from_url=from_url.rstrip("/"), language_code=language_code or get_language()
+        ).first()
 
-    def get_queryset(self):
-        try:
-            return self._annotate_fields(
-                super().get_queryset(),
-                [
-                    (
-                        "indexable",
-                        models.BooleanField(),
-                        models.Value(None, models.BooleanField()),
-                    ),
-                    (
-                        "status",
-                        models.CharField(),
-                        models.Value("DRF", models.CharField()),
-                    ),
-                    (
-                        "publication_date",
-                        models.DateTimeField(),
-                        models.Value(timezone.now(), models.DateTimeField()),
-                    ),
-                    (
-                        "date_updated_at",
-                        models.DateTimeField(),
-                        models.Value(timezone.now(), models.DateTimeField()),
-                    ),
-                ],
-            )
-        except (ProgrammingError, OperationalError):
-            return super().get_queryset()
+    def redirect(self) -> str:
+        return redirect(self.redirect_to, permanent=self.permanent)
+
+    @property
+    def redirect_to(self) -> str:
+        url_to = "/" + self.to_url.lstrip("/")
+        if getattr(django_settings, "APPEND_SLASH", True) and not url_to.endswith("/"):
+            url_to += "/"
+        if (
+            self.language_code != settings.DEFAULT_LANGUAGE
+            and settings.ENABLE_TRANSLATIONS
+        ):
+            url_to = "/" + self.language_code + url_to
+        return url_to + ("?" + self.__q_string if self.__q_string else "")
+
+    class Meta:
+        verbose_name = _("Redirect")
+        verbose_name_plural = _("Redirects")
+        unique_together = ("from_url", "language_code")
+        indexes = [
+            models.Index(fields=["from_url", "language_code"]),
+        ]
 
 
 class UrlNode(models.Model):
 
-    LANG_PERMALINK_FIELDS = [
-        build_localized_fieldname("permalink", lang)
-        for lang in AVAILABLE_LANGUAGES
+    LANG_PERMALINK_FIELDS = (
+        [
+            build_localized_fieldname("permalink", lang)
+            for lang in settings.AVAILABLE_LANGUAGES
+        ]
         if settings.ENABLE_TRANSLATIONS
-    ]
+        else ["permalink"]
+    )
 
     permalink = models.CharField(max_length=400, unique=True, null=True)
     related_name = models.CharField(max_length=200)
@@ -133,7 +119,7 @@ class UrlNode(models.Model):
         return getattr(self, self.related_name)
 
     @staticmethod
-    def reverse_url(permalink: str) -> str:
+    def reverse_url(permalink: str, request: Optional[HttpRequest] = None) -> str:
         append_slash = getattr(django_settings, "APPEND_SLASH", True)
         try:
             if permalink == "/":
@@ -141,6 +127,8 @@ class UrlNode(models.Model):
             url = reverse("camomilla-permalink", args=(permalink.lstrip("/"),))
             if append_slash and not url.endswith("/"):
                 url += "/"
+            if request:
+                url = request.build_absolute_uri(url)
             return url
         except NoReverseMatch:
             return None
@@ -158,14 +146,20 @@ class UrlNode(models.Model):
     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])
+            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)))
+            setattr(
+                self,
+                lang_p_field,
+                UrlNode.sanitize_permalink(getattr(self, lang_p_field)),
+            )
         super().save(*args, **kwargs)
 
     def __str__(self) -> str:
@@ -185,14 +179,20 @@ PAGE_STATUS = (
 
 class PageBase(models.base.ModelBase):
     """
-        This models comes to implement a language based permalink logic
+    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))
+            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):
@@ -203,10 +203,23 @@ class PageBase(models.base.ModelBase):
         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 settings.ENABLE_TRANSLATIONS:
+            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__:
@@ -216,8 +229,20 @@ class PageBase(models.base.ModelBase):
 
 
 class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
+    identifier = models.CharField(max_length=200, null=True, unique=True, default=uuid4)
     date_created = models.DateTimeField(auto_now_add=True)
     date_updated_at = models.DateTimeField(auto_now=True)
+    breadcrumbs_title = models.CharField(max_length=128, null=True, blank=True)
+    template = models.CharField(max_length=500, null=True, blank=True, choices=[])
+    template_data = models.JSONField(default=dict, null=False, blank=True)
+    ordering = models.PositiveIntegerField(default=0, blank=False, null=False)
+    parent_page = models.ForeignKey(
+        "self",
+        related_name=PAGE_CHILD_RELATED_NAME,
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+    )
     url_node = models.OneToOneField(
         UrlNode,
         on_delete=models.CASCADE,
@@ -225,26 +250,14 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         null=True,
         editable=False,
     )
-    breadcrumbs_title = models.CharField(max_length=128, null=True, blank=True)
-    autopermalink = models.BooleanField(default=True)
+    publication_date = models.DateTimeField(null=True, blank=True)
     status = models.CharField(
         max_length=3,
         choices=PAGE_STATUS,
         default="DRF",
     )
-    template = models.CharField(max_length=500, null=True, blank=True, choices=[])
-    template_data = models.JSONField(default=dict, null=False, blank=True)
-    identifier = models.CharField(max_length=200, null=True, unique=True, default=uuid4)
-    publication_date = models.DateTimeField(null=True, blank=True)
     indexable = models.BooleanField(default=True)
-    ordering = models.PositiveIntegerField(default=0, blank=False, null=False)
-    parent_page = models.ForeignKey(
-        "self",
-        related_name=PAGE_CHILD_RELATED_NAME,
-        null=True,
-        blank=True,
-        on_delete=models.CASCADE,
-    )
+    autopermalink = models.BooleanField(default=True)
 
     objects = PageQuerySet.as_manager()
 
@@ -268,7 +281,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def __str__(self) -> str:
         return "(%s) %s" % (self.__class__.__name__, self.title or self.permalink)
 
-    def get_context(self, request=None):
+    def get_context(self, request: Optional[HttpRequest] = None):
         context = {
             "page": self,
             "page_model": {"class": self.__class__.__name__, "module": self.__module__},
@@ -313,7 +326,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
             return bool(publication_date) and timezone.now() > publication_date
         return False
 
-    def get_template_path(self, request=None) -> str:
+    def get_template_path(self, request: Optional[HttpRequest] = None) -> str:
         return self.template or pointed_getter(self, "_page_meta.default_template")
 
     @property
@@ -362,7 +375,10 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     def update_childs(self) -> None:
         # without pk, no childs there
         if self.pk is not None:
-            for child in self.childs.all():
+            exclude_kwargs = {}
+            if self.childs.model == self.__class__:
+                exclude_kwargs["pk"] = self.pk
+            for child in self.childs.exclude(**exclude_kwargs):
                 child.save()
 
     def save(self, *args, **kwargs) -> None:
@@ -371,10 +387,12 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
             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}")
+                hasattr(self, f"__{lang_p_field}") and delattr(
+                    self, f"__{lang_p_field}"
+                )
 
     @classmethod
-    def get(cls, request, *args, **kwargs) -> "AbstractPage":
+    def get(cls, request: HttpRequest, *args, **kwargs) -> "AbstractPage":
         bypass_type_check = kwargs.pop("bypass_type_check", False)
         bypass_public_check = kwargs.pop("bypass_public_check", False)
         if len(kwargs.keys()) > 0:
@@ -407,7 +425,9 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         return page
 
     @classmethod
-    def get_or_create(cls, request, *args, **kwargs) -> Tuple["AbstractPage", bool]:
+    def get_or_create(
+        cls, request: HttpRequest, *args, **kwargs
+    ) -> Tuple["AbstractPage", bool]:
         try:
             return cls.get(request, *args, **kwargs), False
         except ObjectDoesNotExist:
@@ -427,14 +447,14 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
             return cls.get_or_create(None, permalink="/")
 
     @classmethod
-    def get_or_404(cls, request, *args, **kwargs) -> "AbstractPage":
+    def get_or_404(cls, request: HttpRequest, *args, **kwargs) -> "AbstractPage":
         try:
             return cls.get(request, *args, **kwargs)
         except ObjectDoesNotExist as ex:
             raise Http404(ex)
 
     def alternate_urls(self, *args, **kwargs) -> dict:
-        request = False
+        request: Union[HttpRequest, bool] = False
         if len(args) > 0:
             request = args[0]
         if "request" in kwargs:
@@ -444,7 +464,9 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         for lang in activate_languages():
             if lang in permalinks:
                 permalinks[lang] = (
-                    UrlNode.reverse_url(permalinks[lang]) if preview or self.is_public else None
+                    UrlNode.reverse_url(permalinks[lang])
+                    if preview or self.is_public
+                    else None
                 )
             if preview:
                 permalinks = {k: f"{v}?preview=true" for k, v in permalinks.items()}
@@ -470,3 +492,42 @@ class Page(AbstractPage):
 def auto_delete_url_node(sender, instance, **kwargs):
     if issubclass(sender, AbstractPage):
         instance.url_node and instance.url_node.delete()
+
+
+__url_node_history__ = {}
+
+
+@receiver(pre_save, sender=UrlNode)
+def cache_url_node(sender, instance, **kwargs):
+    if instance.pk:
+        __url_node_history__[instance.pk] = sender.objects.filter(
+            pk=instance.pk
+        ).first()
+
+
+@receiver(post_save, sender=UrlNode)
+def generate_redirects(sender, instance, **kwargs):
+    previous = __url_node_history__.pop(instance.pk, None)
+    if previous:
+        redirects = []
+        with transaction.atomic():
+            for lang in activate_languages():
+                new_permalink = get_nofallbacks(instance, "permalink")
+                old_permalink = get_nofallbacks(previous, "permalink")
+                UrlRedirect.objects.filter(
+                    from_url=new_permalink, language_code=lang
+                ).delete()
+                if old_permalink and old_permalink != new_permalink:
+                    redirects.append(
+                        UrlRedirect(
+                            from_url=old_permalink,
+                            to_url=new_permalink,
+                            url_node=instance,
+                            language_code=lang,
+                        )
+                    )
+                    UrlRedirect.objects.filter(
+                        to_url=old_permalink, language_code=lang
+                    ).update(to_url=new_permalink)
+            if len(redirects) > 0:
+                UrlRedirect.objects.bulk_create(redirects)

camomilla/openapi/schema.py

@@ -2,13 +2,11 @@ from rest_framework.schemas.openapi import (
     SchemaGenerator as DRFSchemaGenerator,
     AutoSchema as DRFAutoSchema,
 )
-from camomilla.contrib.rest_framework.serializer import (
-    TranslationsMixin,
-    plain_to_nest,
-    TRANS_ACCESSOR,
-)
-from camomilla.serializers.fields.json import StructuredJSONField
 from camomilla.utils.getters import find_and_replace_dict
+from camomilla.utils.translation import plain_to_nest
+from camomilla.settings import API_TRANSLATION_ACCESSOR
+from camomilla.serializers.mixins import TranslationsMixin
+from structured.contrib.restframework import StructuredJSONField
 
 
 class AutoSchema(DRFAutoSchema):
@@ -18,11 +16,11 @@ class AutoSchema(DRFAutoSchema):
         schema = super(AutoSchema, self).map_serializer(serializer)
         if isinstance(serializer, TranslationsMixin) and serializer.is_translatable:
             schema = plain_to_nest(schema["properties"], serializer.translation_fields)
-            schema[TRANS_ACCESSOR] = {
+            schema[API_TRANSLATION_ACCESSOR] = {
                 "type": "object",
                 "properties": {
                     k: {"type": "object", "properties": v}
-                    for k, v in schema[TRANS_ACCESSOR].items()
+                    for k, v in schema[API_TRANSLATION_ACCESSOR].items()
                 },
             }
         return schema
@@ -55,8 +53,15 @@ 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:
+        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__])
+            setattr(
+                view,
+                attname,
+                [p for p in getattr(view, attname, []) if cname not in p.__name__],
+            )
         return view

camomilla/redirects.py

@@ -0,0 +1,10 @@
+from django.urls import path
+from django.shortcuts import redirect
+
+
+url_patterns = [
+    path(
+        "profiles/me/", lambda _: redirect("../../users/current/"), name="profiles-me"
+    ),
+    path("sitemap/", lambda _: redirect("../pages/"), name="sitemap"),
+]

camomilla/serializers/base/__init__.py

@@ -1,14 +1,14 @@
 from rest_framework import serializers
 
-from ...contrib.rest_framework.serializer import TranslationsMixin
-from ..fields import FieldsOverrideMixin
-from ..mixins import (
+from camomilla.serializers.mixins import (
     JSONFieldPatchMixin,
     NestMixin,
     OrderingMixin,
     SetupEagerLoadingMixin,
+    FilterFieldsMixin,
+    FieldsOverrideMixin,
+    TranslationsMixin,
 )
-from ..mixins.filter_fields import FilterFieldsMixin
 
 
 class BaseModelSerializer(

camomilla/serializers/fields/__init__.py

@@ -1,21 +1,9 @@
-from django.db import models
-from rest_framework import serializers
-
-from structured.fields import StructuredJSONField as ModelStructuredJSONField
-
-from .json import StructuredJSONField
 from .file import FileField, ImageField
 from .related import RelatedField
 
 
-class FieldsOverrideMixin:
-    """
-    This mixin automatically overrides the fields of the serializer with camomilla's backed ones.
-    """
-    serializer_field_mapping = {
-        **serializers.ModelSerializer.serializer_field_mapping,
-        models.FileField: FileField,
-        models.ImageField: ImageField,
-        ModelStructuredJSONField: StructuredJSONField,
-    }
-    serializer_related_field = RelatedField
+__all__ = [
+    "FileField",
+    "ImageField",
+    "RelatedField",
+]

camomilla/serializers/fields/related.py

@@ -97,9 +97,11 @@ class RelatedField(serializers.PrimaryKeyRelatedField):
                     for item in child.get_queryset().filter(
                         **{
                             f"{child.lookup}__in": [
-                                item.get(child.lookup, None)
-                                if isinstance(item, dict)
-                                else item
+                                (
+                                    item.get(child.lookup, None)
+                                    if isinstance(item, dict)
+                                    else item
+                                )
                                 for item in data
                             ]
                         }