django-camomilla-cms 6.0.0b2__py2.py3-none-any.whl → 6.0.0b4__py2.py3-none-any.whl

camomilla/__init__.py

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

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()

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))

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

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))

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]

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):

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,
             },

camomilla/models/__init__.py

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

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

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):

camomilla/models/menu.py

@@ -1,68 +1,67 @@
+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 Union
+from typing import Optional, Union, Callable
 
 
-class MenuNodeLink(structured.Model):
-    link_type = structured.CharField()
-    static = structured.CharField()
-    url_node = structured.ForeignKey(UrlNode)
-    content_type = structured.IntegerField()
-    page_id = structured.IntegerField()
+class LinkTypes(str, Enum):
+    relational = "RE"
+    static = "ST"
 
-    @classmethod
-    def to_db_transform(cls, data):
-        if data.get("link_type", None) == "RE":
-            ct_id = data.get("content_type", None)
-            p_id = data.get("page_id", None)
-            if ct_id and p_id:
-                c_type = ContentType.objects.filter(pk=ct_id).first()
+
+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=p_id).first()
-                if page:
-                    data["url_node"] = page.url_node.pk
-                else:
-                    data["url_node"] = None
-        return data
+                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 == "RE":
-            return self.url_node and self.url_node.routerlink
-        elif self.link_type == "ST":
+        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):
+    def url(self) -> Optional[str]:
         return self.get_url()
 
 
-class MenuNode(structured.Model):
-    id = structured.CharField()
-    meta = structured.DictField()
-    nodes = structured.ListField(items_types=("MenuNode",))
-    title = structured.CharField()
-    link = structured.EmbeddedField("MenuNodeLink")
-
-    @classmethod
-    def to_db_transform(cls, data):
-        link = data.pop("link", {})
-        nodes = data.pop("nodes", {})
-        return {
-            "link": MenuNodeLink.to_db_transform(link),
-            "nodes": [cls.to_db_transform(n) for n in nodes],
-            **data,
-        }
+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)
-    available_classes = models.JSONField(default=dict)
+    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)
 
@@ -85,3 +84,6 @@ class Menu(models.Model):
         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

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)

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

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):

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):