django-camomilla-cms 6.0.0b15__py2.py3-none-any.whl → 6.0.0b17__py2.py3-none-any.whl

camomilla/__init__.py

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

camomilla/contrib/modeltranslation/hvad_migration.py

@@ -56,12 +56,12 @@ class KeepTranslationsMixin:
                         )
                     )
                     rows = cursor.fetchall()
-                    self._saved_data_from_plain[
-                        modelPath
-                    ] = self._saved_data_from_plain.get(modelPath, {})
-                    self._saved_data_from_plain[modelPath][
-                        master[0]
-                    ] = self._saved_data_from_plain[modelPath].get(master[0], [])
+                    self._saved_data_from_plain[modelPath] = (
+                        self._saved_data_from_plain.get(modelPath, {})
+                    )
+                    self._saved_data_from_plain[modelPath][master[0]] = (
+                        self._saved_data_from_plain[modelPath].get(master[0], [])
+                    )
                     for row in rows:
                         self._saved_data_from_plain[modelPath][master[0]].append(
                             dict(zip(fields, row))
@@ -83,9 +83,9 @@ class KeepTranslationsMixin:
                         )
                     )
                     rows = cursor.fetchall()
-                    self._saved_data_from_plain[
-                        modelPath
-                    ] = self._saved_data_from_plain.get(modelPath, [])
+                    self._saved_data_from_plain[modelPath] = (
+                        self._saved_data_from_plain.get(modelPath, [])
+                    )
                     for row in rows:
                         row_data = dict(zip(("master_id", *fields), row))
                         row_data.update({"language_code": lang})

camomilla/dynamic_pages_urls.py

@@ -3,15 +3,19 @@ from django.urls import path
 
 from camomilla import settings
 from django.conf import settings as django_settings
-from .models import Page
+from .models import Page, UrlRedirect
 
 
 def fetch(request, *args, **kwargs):
     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)
+    redirect_obj = UrlRedirect.find_redirect(request)
+    if redirect_obj:
+        return redirect_obj.redirect()
     if append_slash and not request.path.endswith("/"):
-        return redirect(request.path + "/")
+        q_string = request.META.get("QUERY_STRING", "")
+        return redirect(request.path + "/" + ("?" + q_string if q_string else ""))
     if "permalink" in kwargs:
         page = Page.get_or_404(
             request, bypass_public_check=preview, bypass_type_check=True

camomilla/managers/pages.py

@@ -1,31 +1,116 @@
 from django.db.models.query import QuerySet
 from django.core.exceptions import ObjectDoesNotExist
 from django.apps import apps
+from django.db import models
+from django.utils import timezone
+from django.db.utils import ProgrammingError, OperationalError
+from typing import Sequence, Tuple
 
 URL_NODE_RELATED_NAME = "%(app_label)s_%(class)s"
 
 
 class PageQuerySet(QuerySet):
-    
+
     __UrlNodeModel = None
-    
+
     @property
     def UrlNodeModel(self):
         if not self.__UrlNodeModel:
             self.__UrlNodeModel = apps.get_model("camomilla", "UrlNode")
-        return self.__UrlNodeModel 
-    
+        return self.__UrlNodeModel
+
     def get_permalink_kwargs(self, kwargs):
-        return list(set(kwargs.keys()).intersection(set(self.UrlNodeModel.LANG_PERMALINK_FIELDS + ["permalink"])))
-    
+        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})
+                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
                 )
-        return super(PageQuerySet, self).get(*args, **kwargs)
+        return super(PageQuerySet, self).get(*args, **kwargs)
+
+
+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),
+            )
+        )
+
+    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()

camomilla/model_api.py

@@ -26,6 +26,7 @@ def register(
     """
 
     def inner(model):
+        global urlpatterns
         base_meta = {
             "model": model,
             "fields": "__all__",
@@ -47,13 +48,17 @@ 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,
             },
@@ -61,9 +66,11 @@ def register(
 
         model_path = "".join(
             [
-                "-" + character.lower()
-                if character.isupper() and index > 0
-                else character
+                (
+                    "-" + character.lower()
+                    if character.isupper() and index > 0
+                    else character
+                )
                 for index, character in enumerate(model.__name__)
             ]
         ).lstrip("-")
@@ -73,7 +80,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

@@ -14,7 +14,6 @@ from pydantic import (
 )
 from structured.pydantic.models import BaseModel
 from structured.fields import StructuredJSONField
-from structured.pydantic.fields import QuerySet
 from camomilla.models.page import UrlNode, AbstractPage
 from typing import Optional, Union, Callable, List
 from django.db.models.base import Model as DjangoModel
@@ -37,7 +36,9 @@ class MenuNodeLink(BaseModel):
         if self.link_type == LinkTypes.relational:
             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__)
+                    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()
@@ -47,7 +48,9 @@ class MenuNodeLink(BaseModel):
             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__)
+                self.content_type = ContentType.objects.get_for_model(
+                    self.page.__class__
+                )
         return handler(self)
 
     def get_url(self, request=None):
@@ -88,7 +91,10 @@ class Menu(models.Model):
     ):
         if isinstance(context, RequestContext):
             context = context.flatten()
-        context.update({"menu": self})
+        is_preview = (
+            False if request is None else 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):