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

camomilla/{contrib/rest_framework/serializer.py → serializers/mixins/translation.py}

@@ -1,7 +1,5 @@
 from functools import cached_property
-from typing import Iterable, Union, List
-from django.http import QueryDict
-
+from typing import Iterable, List
 from modeltranslation import settings as mt_settings
 from modeltranslation.translator import NotRegistered, translator
 from modeltranslation.utils import build_localized_fieldname
@@ -9,50 +7,8 @@ from rest_framework import serializers
 from rest_framework.exceptions import ValidationError
 from camomilla.utils.getters import pointed_getter
 from camomilla.utils.translation import is_translatable
-
-
-TRANS_ACCESSOR = "translations"
-
-
-def plain_to_nest(data, fields, accessor=TRANS_ACCESSOR):
-    """
-    This function transforms a plain dictionary with translations fields (es. {"title_en": "Hello"})
-    into a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}}).
-    """
-    trans_data = {}
-    for lang in mt_settings.AVAILABLE_LANGUAGES:
-        lang_data = {}
-        for field in fields:
-            trans_field_name = build_localized_fieldname(field, lang)
-            if trans_field_name in data:
-                lang_data[field] = data.pop(trans_field_name)
-        if lang_data.keys():
-            trans_data[lang] = lang_data
-    if trans_data.keys():
-        data[accessor] = trans_data
-    return data
-
-
-def nest_to_plain(data: Union[dict, QueryDict], fields: List[str], accessor=TRANS_ACCESSOR):
-    """
-    This function is the inverse of plain_to_nest.
-    It transforms a dictionary with nested translations fields (es. {"translations": {"en": {"title": "Hello"}}})
-    into a plain dictionary with translations fields (es. {"title_en": "Hello"}).
-    """
-    if isinstance(data, QueryDict):
-        data = data.dict()
-    translations = data.pop(accessor, {})
-    for lang in mt_settings.AVAILABLE_LANGUAGES:
-        nest_trans = translations.pop(lang, {})
-        for k in fields:
-            data.pop(k, None)  # this removes all trans field without lang
-            if k in nest_trans:
-                # this saves on the default field the default language value
-                if lang == mt_settings.DEFAULT_LANGUAGE:
-                    data[k] = nest_trans[k]
-                key = build_localized_fieldname(k, lang)
-                data[key] = data.get(key, nest_trans[k])
-    return data
+from camomilla.utils.translation import nest_to_plain, plain_to_nest
+from camomilla.settings import API_TRANSLATION_ACCESSOR
 
 
 class TranslationsMixin(serializers.ModelSerializer):
@@ -67,6 +23,16 @@ class TranslationsMixin(serializers.ModelSerializer):
     `{"translations": {"en": {"title": "Hello"}, "it": {"title": "Ciao"}}` -> `{"title_en": "Hello", "title_it": "Ciao"}`
     """
 
+    def _transform_input(self, data):
+        return nest_to_plain(
+            data, self.translation_fields or [], API_TRANSLATION_ACCESSOR
+        )
+
+    def _transform_output(self, data):
+        return plain_to_nest(
+            data, self.translation_fields or [], API_TRANSLATION_ACCESSOR
+        )
+
     @cached_property
     def translation_fields(self) -> List[str]:
         try:
@@ -81,22 +47,16 @@ class TranslationsMixin(serializers.ModelSerializer):
                 yield field
 
     def to_internal_value(self, data):
-        if self.translation_fields:
-            nest_to_plain(data, self.translation_fields)
-        return super().to_internal_value(data)
+        return super().to_internal_value(self._transform_input(data))
 
     def to_representation(self, instance):
-        representation = super().to_representation(instance)
-        if self.translation_fields:
-            plain_to_nest(representation, self.translation_fields)
-        return representation
+        return self._transform_output(super().to_representation(instance))
 
     def run_validation(self, *args, **kwargs):
         try:
             return super().run_validation(*args, **kwargs)
         except ValidationError as ex:
-            if self.translation_fields:
-                plain_to_nest(ex.detail, self.translation_fields)
+            ex.detail.update(self._transform_input(ex.detail))
             raise ValidationError(detail=ex.detail)
 
     @property

camomilla/serializers/utils.py

@@ -1,13 +1,13 @@
 def get_standard_bases() -> tuple:
     from rest_framework.serializers import ModelSerializer
-    from camomilla.serializers.fields import FieldsOverrideMixin
-    from camomilla.serializers.mixins.filter_fields import FilterFieldsMixin
-    from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
     from camomilla.serializers.mixins import (
         JSONFieldPatchMixin,
         NestMixin,
         OrderingMixin,
         SetupEagerLoadingMixin,
+        FieldsOverrideMixin,
+        FilterFieldsMixin,
+        RemoveTranslationsMixin,
     )
 
     return (

camomilla/serializers/validators.py

@@ -31,9 +31,13 @@ class UniquePermalinkValidator:
         for language in activate_languages():
             autopermalink_f = build_localized_fieldname("autopermalink", language)
             f_name = build_localized_fieldname("permalink", language)
-            permalink = value.get(f_name, instance and get_nofallbacks(instance, "permalink"))
+            permalink = value.get(
+                f_name, instance and get_nofallbacks(instance, "permalink")
+            )
             permalink = UrlNode.sanitize_permalink(permalink)
-            autopermalink = value.get(autopermalink_f, instance and get_nofallbacks(instance, "autopermalink"))
+            autopermalink = value.get(
+                autopermalink_f, instance and get_nofallbacks(instance, "autopermalink")
+            )
             if autopermalink:
                 continue
             fake_instance = serializer.Meta.model()

camomilla/settings.py

@@ -1,5 +1,5 @@
 from django.conf import settings as django_settings
-from modeltranslation.settings import ENABLE_REGISTRATIONS
+from modeltranslation.settings import ENABLE_REGISTRATIONS, AVAILABLE_LANGUAGES
 
 from camomilla.utils.getters import pointed_getter
 
@@ -53,6 +53,10 @@ ENABLE_TRANSLATIONS = (
     ENABLE_REGISTRATIONS and "modeltranslation" in django_settings.INSTALLED_APPS
 )
 
+DEFAULT_LANGUAGE = pointed_getter(django_settings, "LANGUAGE_CODE", "en")
+
+LANGUAGE_CODES = AVAILABLE_LANGUAGES
+
 MEDIA_OPTIMIZE_MAX_WIDTH = pointed_getter(
     django_settings, "CAMOMILLA.MEDIA.OPTIMIZE.MAX_WIDTH", 1980
 )
@@ -79,6 +83,15 @@ TEMPLATE_CONTEXT_FILES = pointed_getter(
     django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
 )
 
+API_TRANSLATION_ACCESSOR = pointed_getter(
+    django_settings, "CAMOMILLA.API.TRANSLATION_ACCESSOR", "translations"
+)
+
+REGISTERED_TEMPLATES_APPS = pointed_getter(
+    django_settings,
+    "CAMOMILLA.RENDER.REGISTERED_TEMPLATES_APPS", None
+)
+
 DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
 
 # camomilla settings example
@@ -96,10 +109,11 @@ DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG
 #         "AUTO_CREATE_HOMEPAGE": True,
 #         "ARTICLE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None },
 #         "PAGE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None }
+#         "REGISTERED_TEMPLATE_APPS": []
 #     },
 #     "STRUCTURED_FIELD": {
 #         "CACHE_ENABLED": True
 #     }
-#     "API": {"NESTING_DEPTH": 10 },
+#     "API": {"NESTING_DEPTH": 10, "TRANSLATION_ACCESSOR": "translations"},
 #     "DEBUG": False
 # }

camomilla/storages/default.py

@@ -1,6 +1,12 @@
 from django.utils.module_loading import import_string
 from django.conf import settings
 
+from django import VERSION as DJANGO_VERSION
+
 
 def get_default_storage_class():
-    return import_string(settings.STORAGES["default"]["BACKEND"])
+    if DJANGO_VERSION >= (4, 2):
+        storage = settings.STORAGES["default"]["BACKEND"]
+    else:
+        storage = settings.DEFAULT_FILE_STORAGE
+    return import_string(storage)

camomilla/templates/defaults/base.html

@@ -1,5 +1,7 @@
 {% load menus %}
 {% load i18n %}
+{% load model_extras %}
+
 {% get_current_language as current_lang %}
 
 
@@ -9,9 +11,6 @@
     <title>Camomilla CMS</title>
     <style>
         html,
-        body {
-            height: 100%;
-        }
 
         body {
             background-color: #f7fafc;
@@ -49,6 +48,45 @@
             font-size: 18px;
             font-style: italic;
         }
+        .accordion {
+            margin: 2rem auto;
+            border: 1px solid #000;
+            font-family: monospace;
+            width: 800px;
+            max-width: 800px;
+        }
+
+        .accordion-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 0.75rem 1rem;
+            cursor: pointer;
+            user-select: none;
+        }
+
+        .accordion-icon {
+            width: 1rem;
+            height: 1rem;
+            transition: transform 0.3s ease;
+        }
+
+        .accordion-toggle:checked + .accordion-header .accordion-icon {
+            transform: rotate(180deg);
+        }
+
+        .accordion-body {
+            max-height: 0;
+            overflow: hidden;
+            transition: max-height 0.3s ease;
+        }
+
+        .accordion-toggle:checked + .accordion-header + .accordion-body {
+            max-height: 30vh;
+            padding: 1rem;
+            border-top: 1px solid #000;
+            overflow-y: auto;
+        }
     </style>
 </head>
 
@@ -104,11 +142,29 @@
         - <b>Module:</b> {{page_model.module}} <br>
         - <b>Identifier:</b> {{page.pk}} <br>
         - <b>Permalink:</b> {{page.permalink}} <br>
-        - <b>Language:</b> {{current_lang}} <br>        
+        - <b>Language:</b> {{current_lang}} <br>             
     </code>
+    
     {% endblock %}
+
     {% block content %}
     {% endblock %}
+    
+    <div class="accordion">
+    <input type="checkbox" id="accordion-toggle" class="accordion-toggle" hidden>
+    <label for="accordion-toggle" class="accordion-header">
+        <span>Page data</span>
+        <svg class="accordion-icon" viewBox="0 0 24 24">
+        <path d="M6 9l6 6 6-6" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round"/>
+        </svg>
+    </label>
+    <div class="accordion-body">
+        <pre>{{ page|to_pretty_dict|safe }}</pre>
+    </div>
+</div>
+
+</div>
+
 </body>
 
 </html>

camomilla/templates/defaults/parts/menu.html

@@ -4,7 +4,7 @@
   {% for item in menu.nodes %}
   <li>
     {% if item.link.url %}
-      <a href="{{ item.link.url }}{% if is_preview %}?preview=true{% endif %}">{{ item.title }}</a>
+      <a href="{{ item|node_url }}{% if is_preview %}?preview=true{% endif %}">{{ item.title }}</a>
     {% else %}
       <span>{{item.title}}</span>
     {% endif %}

camomilla/templatetags/menus.py

@@ -22,6 +22,9 @@ def render_menu(
     menu_key: str,
     template_path: str = "defaults/parts/menu.html",
 ):
+    if context is not None and not isinstance(context, dict):
+        context = context.__dict__
+
     return context.get("menus", Menu.defaultdict())[menu_key].render(
         template_path=template_path,
         context=context,

camomilla/templatetags/model_extras.py

@@ -0,0 +1,73 @@
+from django import template
+from django.utils.safestring import mark_safe
+from django.forms.models import model_to_dict
+from structured.pydantic.models import BaseModel
+import json
+import re
+import html
+from datetime import datetime
+
+register = template.Library()
+
+
+def custom_json_serializer(obj):
+    """Serialize custom objects to JSON."""
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    raise TypeError(f"Type {type(obj)} not serializable")
+
+
+def pretty_dict(data, indent_level=0):
+    """
+    Recursive function to format a dictionary into a pretty string.
+    Args:
+        data (dict): The dictionary to format.
+        indent_level (int): The current indentation level.
+    Returns:
+        str: A pretty-printed string representation of the dictionary.
+    """
+    indent = "  " * indent_level
+    result = []
+
+    for key, value in data.items():
+
+        if isinstance(value, dict):
+            result.append(f"{indent}'{key}': {{")
+            result.append(pretty_dict(value, indent_level + 1))
+            result.append(f"{indent}}},")
+
+        elif isinstance(value, list):
+            result.append(f"{indent}'{key}': [")
+            for item in value:
+                if isinstance(item, dict):
+                    result.append(pretty_dict(item, indent_level + 1))
+                else:
+                    result.append(f"{indent}  {json.dumps(item, default=custom_json_serializer)},")
+            result.append(f"{indent}],")
+
+        else:
+            result.append(f"{indent}'{key}': {json.dumps(value, default=custom_json_serializer)},")
+
+    return "\n".join(result).rstrip(',')
+
+
+@register.filter
+def to_pretty_dict(instance):
+    data = model_to_dict(instance)
+
+    for key, value in data.items():
+        if isinstance(value, BaseModel):
+            data[key] = value.model_dump()
+
+    formatted_dict = "{\n" + pretty_dict(data, indent_level=1) + "\n}"
+
+    escaped = html.escape(formatted_dict)
+
+    # This to highlight the keys in the JSON
+    highlighted = re.sub(
+        r"(')([^&#]+?)('):",
+        r"<span style='color:#df3079'>'\2'</span>:",
+        escaped
+    )
+
+    return mark_safe(f"<pre>{highlighted}</pre>")

camomilla/theme/__init__.py

@@ -1 +1 @@
-__version__ = "6.0.0-beta.16"
+__version__ = "6.0.0-beta.18"

camomilla/theme/{admin.py → admin/__init__.py}

@@ -1,33 +1,30 @@
-from ckeditor_uploader.widgets import CKEditorUploadingWidget
+from tinymce.widgets import TinyMCE
 from django import forms
 from django.contrib import admin
 from django.http import HttpResponse
-
-from camomilla import settings
-
-if settings.ENABLE_TRANSLATIONS:
-    from modeltranslation.admin import (
-        TabbedTranslationAdmin as TranslationAwareModelAdmin,
-    )
-else:
-    from django.contrib.admin import ModelAdmin as TranslationAwareModelAdmin
-
-from camomilla.models import Article, Content, Media, MediaFolder, Page, Tag, Menu
-
-
-class AbstractPageAdmin(TranslationAwareModelAdmin):
-    change_form_template = "admin/camomilla/page/change_form.html"
+from .pages import AbstractPageModelForm, AbstractPageAdmin
+from .translations import TranslationAwareModelAdmin
+from camomilla.models import (
+    Article,
+    Content,
+    Media,
+    MediaFolder,
+    Page,
+    Tag,
+    Menu,
+    UrlRedirect,
+)
 
 
 class UserProfileAdmin(admin.ModelAdmin):
     pass
 
 
-class ArticleAdminForm(forms.ModelForm):
+class ArticleAdminForm(AbstractPageModelForm):
     class Meta:
         model = Article
         fields = "__all__"
-        widgets = {"content": CKEditorUploadingWidget}
+        widgets = {"content": TinyMCE()}
 
 
 class ArticleAdmin(AbstractPageAdmin):
@@ -47,7 +44,7 @@ class ContentAdminForm(forms.ModelForm):
     class Meta:
         model = Content
         fields = "__all__"
-        widgets = {"content": CKEditorUploadingWidget}
+        widgets = {"content": TinyMCE()}
 
 
 class ContentAdmin(TranslationAwareModelAdmin):
@@ -81,13 +78,17 @@ class MediaAdmin(TranslationAwareModelAdmin):
 
 
 class PageAdmin(AbstractPageAdmin):
-    readonly_fields = ("permalink",)
+    pass
 
 
 class MenuAdmin(TranslationAwareModelAdmin):
     pass
 
 
+class UrlRedirectAdmin(admin.ModelAdmin):
+    pass
+
+
 admin.site.register(Article, ArticleAdmin)
 admin.site.register(MediaFolder, MediaFolderAdmin)
 admin.site.register(Tag, TagAdmin)
@@ -95,3 +96,4 @@ admin.site.register(Content, ContentAdmin)
 admin.site.register(Media, MediaAdmin)
 admin.site.register(Page, PageAdmin)
 admin.site.register(Menu, MenuAdmin)
+admin.site.register(UrlRedirect, UrlRedirectAdmin)

camomilla/theme/admin/pages.py

@@ -0,0 +1,46 @@
+from django import forms
+from camomilla import settings
+from .translations import TranslationAwareModelAdmin
+from camomilla.models import UrlNode
+
+
+class AbstractPageModelFormMeta(forms.models.ModelFormMetaclass):
+    def __new__(mcs, name, bases, attrs):
+        new_class = super().__new__(mcs, name, bases, attrs)
+        fields_to_add = forms.fields_for_model(UrlNode, UrlNode.LANG_PERMALINK_FIELDS)
+        if settings.ENABLE_TRANSLATIONS:
+            for i, field_name in enumerate(fields_to_add.keys()):
+                field_classes = ["mt", f"mt-field-{field_name.replace('_', '-')}"]
+                i == 0 and field_classes.append("mt-default")
+                fields_to_add[field_name].widget.attrs.update(
+                    {"class": " ".join(field_classes)}
+                )
+        new_class.base_fields.update(fields_to_add)
+        return new_class
+
+
+class AbstractPageModelForm(
+    forms.models.BaseModelForm, metaclass=AbstractPageModelFormMeta
+):
+
+    def get_initial_for_field(self, field, field_name):
+        if field_name in UrlNode.LANG_PERMALINK_FIELDS:
+            return getattr(self.instance, field_name)
+        return super().get_initial_for_field(field, field_name)
+
+    def save(self, commit: bool = True):
+        model = super().save(commit=False)
+        for field_name in UrlNode.LANG_PERMALINK_FIELDS:
+            if field_name in self.cleaned_data:
+                if getattr(model, field_name) != self.cleaned_data[field_name]:
+                    # sets autopermalink to False if permalink is manually set
+                    setattr(model, f"auto{field_name}", False)
+                setattr(model, field_name, self.cleaned_data[field_name])
+        if commit:
+            model.save()
+        return model
+
+
+class AbstractPageAdmin(TranslationAwareModelAdmin):
+    form = AbstractPageModelForm
+    change_form_template = "admin/camomilla/page/change_form.html"

camomilla/theme/admin/translations.py

@@ -0,0 +1,13 @@
+from camomilla import settings
+
+if settings.ENABLE_TRANSLATIONS:
+    from modeltranslation.admin import (
+        TabbedTranslationAdmin as TranslationAwareModelAdmin,
+    )
+else:
+    from django.contrib.admin import ModelAdmin as TranslationAwareModelAdmin
+
+
+__all__ = [
+    "TranslationAwareModelAdmin",
+]

camomilla/theme/apps.py

@@ -29,13 +29,10 @@ class CamomillaThemeConfig(AppConfig):
     name = "camomilla.theme"
 
     def ready(self):
-        set_default_settings(
-            CKEDITOR_UPLOAD_PATH="editor-uploads/", X_FRAME_OPTIONS="SAMEORIGIN"
-        )
         add_apps(
-            "ckeditor_uploader",
-            "ckeditor",
+            "tinymce",
             "django_jsonform",
             "admin_interface",
             "colorfield",
+            "structured",
         )

camomilla/translation.py

@@ -16,7 +16,13 @@ class SeoMixinTranslationOptions(TranslationOptions):
 
 
 class AbstractPageTranslationOptions(SeoMixinTranslationOptions):
-    fields = ("breadcrumbs_title", "autopermalink", "status", "indexable", "template_data")
+    fields = (
+        "breadcrumbs_title",
+        "autopermalink",
+        "status",
+        "indexable",
+        "template_data",
+    )
 
 
 @register(Article)

camomilla/urls.py

@@ -1,4 +1,3 @@
-from django.shortcuts import redirect
 from django.urls import include, path
 from rest_framework import routers
 from importlib.util import find_spec
@@ -21,6 +20,7 @@ from camomilla.views import (
     MenuViewSet,
 )
 from camomilla.views.pages import fetch_page
+from camomilla.redirects import url_patterns as old_redirects
 
 router = routers.DefaultRouter()
 
@@ -30,18 +30,15 @@ router.register(r"contents", ContentViewSet, "camomilla-content")
 router.register(r"media", MediaViewSet, "camomilla-media")
 router.register(r"media-folders", MediaFolderViewSet, "camomilla-media_folders")
 router.register(r"pages", PageViewSet, "camomilla-pages")
-router.register(r"sitemap", PageViewSet, "camomilla-sitemap")
 router.register(r"users", UserViewSet, "camomilla-users")
 router.register(r"permissions", PermissionViewSet, "camomilla-permissions")
 router.register(r"menus", MenuViewSet, "camomilla-menus")
 
 urlpatterns = [
+    *old_redirects,
     path("", include(router.urls)),
     path("pages-router/", fetch_page),
     path("pages-router/<path:permalink>", fetch_page),
-    path(
-        "profiles/me/", lambda _: redirect("../../users/current/"), name="profiles-me"
-    ),
     path("token-auth/", CamomillaObtainAuthToken.as_view(), name="api_token"),
     path("auth/login/", CamomillaAuthLogin.as_view(), name="login"),
     path("auth/logout/", CamomillaAuthLogout.as_view(), name="logout"),