django-camomilla-cms 6.0.0b15__py2.py3-none-any.whl → 6.0.0b17__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,21 +1,23 @@
 def get_standard_bases() -> tuple:
     from rest_framework.serializers import ModelSerializer
-    from camomilla.serializers.fields import FieldsOverrideMixin
-    from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
     from camomilla.serializers.mixins import (
         JSONFieldPatchMixin,
         NestMixin,
         OrderingMixin,
         SetupEagerLoadingMixin,
+        FieldsOverrideMixin,
+        FilterFieldsMixin,
+        RemoveTranslationsMixin,
     )
 
     return (
+        SetupEagerLoadingMixin,
+        FilterFieldsMixin,
         NestMixin,
         FieldsOverrideMixin,
         JSONFieldPatchMixin,
         OrderingMixin,
         RemoveTranslationsMixin,
-        SetupEagerLoadingMixin,
         ModelSerializer,
     )
 

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,10 @@ TEMPLATE_CONTEXT_FILES = pointed_getter(
     django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
 )
 
+API_TRANSLATION_ACCESSOR = pointed_getter(
+    django_settings, "CAMOMILLA.API.TRANSLATION_ACCESSOR", "translations"
+)
+
 DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
 
 # camomilla settings example
@@ -100,6 +108,6 @@ DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG
 #     "STRUCTURED_FIELD": {
 #         "CACHE_ENABLED": True
 #     }
-#     "API": {"NESTING_DEPTH": 10 },
+#     "API": {"NESTING_DEPTH": 10, "TRANSLATION_ACCESSOR": "translations"},
 #     "DEBUG": False
 # }

camomilla/storages/default.py

@@ -0,0 +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():
+    if DJANGO_VERSION >= (4, 2):
+        storage = settings.STORAGES["default"]["BACKEND"]
+    else:
+        storage = settings.DEFAULT_FILE_STORAGE
+    return import_string(storage)

camomilla/storages/optimize.py

@@ -2,13 +2,13 @@ import traceback
 from io import BytesIO
 
 from django.core.files.base import ContentFile
-from django.core.files.storage import get_storage_class
 from PIL import Image
 
 from camomilla import settings
+from camomilla.storages.default import get_default_storage_class
 
 
-class OptimizedStorage(get_storage_class()):
+class OptimizedStorage(get_default_storage_class()):
     MEDIA_MAX_WIDTH = settings.MEDIA_OPTIMIZE_MAX_WIDTH
     MEDIA_MAX_HEIGHT = settings.MEDIA_OPTIMIZE_MAX_HEIGHT
     MEDIA_DPI = settings.MEDIA_OPTIMIZE_DPI

camomilla/storages/overwrite.py

@@ -1,7 +1,7 @@
-from django.core.files.storage import get_storage_class
+from camomilla.storages.default import get_default_storage_class
 
 
-class OverwriteStorage(get_storage_class()):
+class OverwriteStorage(get_default_storage_class()):
     def _save(self, name, content):
         if self.exists(name):
             self.delete(name)

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 }}">{{ 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/theme/__init__.py

@@ -1 +1 @@
-__version__ = "6.0.0-beta.15"
+__version__ = "6.0.0-beta.17"

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,12 +29,8 @@ 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",

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

camomilla/utils/query_parser.py

@@ -0,0 +1,167 @@
+import re
+from django.db.models import Q
+from typing import List, Dict, Optional
+
+
+class ConditionParser:
+    CONDITION_PATTERN = re.compile(
+        r"(\w+__\w+='[^']+'|\w+__\w+=\S+|\w+='[^']+'|\w+=\S+)"
+    )
+    LOGICAL_OPERATORS = {"AND", "OR"}
+
+    __db_query: Optional[Q] = None
+
+    def __init__(self, query: str):
+        self.__db_query = None
+        self.query = query
+
+    def parse(self, query: str = None) -> Dict:
+        """Parse the query or subquery. If no query is provided, use the instance's query."""
+        if query is None:
+            query = self.query
+
+        tokens = self.tokenize(query)
+        # If there's just one token and it's a dictionary (single condition), return it
+        if len(tokens) == 1 and isinstance(tokens[0], dict):
+            return tokens[0]
+        return self.build_tree(tokens)
+
+    def tokenize(self, query: str) -> List:
+        tokens = []
+        i = 0
+        while i < len(query):
+            if query[i] == "(":
+                j = i + 1
+                open_parens = 1
+                while j < len(query) and open_parens > 0:
+                    if query[j] == "(":
+                        open_parens += 1
+                    elif query[j] == ")":
+                        open_parens -= 1
+                    j += 1
+                if open_parens == 0:
+                    subquery = query[i + 1 : j - 1]
+                    tokens.append(self.parse(subquery))  # Pass the subquery here
+                    i = j
+                else:
+                    raise ValueError("Mismatched parentheses")
+            elif query[i : i + 3] == "AND" or query[i : i + 2] == "OR":
+                operator = "AND" if query[i : i + 3] == "AND" else "OR"
+                tokens.append(operator)
+                i += 3 if operator == "AND" else 2
+            else:
+                match = self.CONDITION_PATTERN.match(query[i:])
+                if match:
+                    condition = self.parse_condition(match.group())
+                    tokens.append(condition)
+                    i += match.end()
+                else:
+                    i += 1
+        return tokens
+
+    def parse_condition(self, condition: str) -> Optional[Dict]:
+        """Parse a single condition into field lookup and value."""
+        if "=" in condition:
+            field_lookup, value = condition.split("=")
+            value = value.strip("'").strip('"')  # Remove single or double quotes
+            value = self.parse_value(value)  # Parse the value
+            return {"field_lookup": field_lookup, "value": value}
+        return None
+
+    def parse_value(self, string: str):
+        """Parse single condition values based on specific rules."""
+        if string and string.startswith("[") and string.endswith("]"):
+            string = [self.parse_value(substr) for substr in string[1:-1].split(",")]
+        elif string and string.lower() in ["true", "false"]:
+            string = string.lower() == "true"
+        elif string and string.isdigit():
+            string = int(string)
+        return string
+
+    def build_tree(self, tokens: List[str]) -> Dict:
+        """Build a tree-like structure with operators and conditions."""
+        if not tokens:
+            return None
+
+        output_stack = []
+        operator_stack = []
+
+        # Process each token in the query
+        for token in tokens:
+            if isinstance(token, dict):
+                # Handle a single condition
+                if operator_stack:
+                    operator = operator_stack.pop()
+                    if isinstance(output_stack[-1], dict):
+                        output_stack[-1] = {
+                            "operator": operator,
+                            "conditions": [output_stack[-1], token],
+                        }
+                    else:
+                        output_stack[-1]["conditions"].append(token)
+                else:
+                    output_stack.append(token)
+
+            elif token in self.LOGICAL_OPERATORS:
+                # Operator found (AND/OR), handle precedence
+                operator_stack.append(token)
+
+        # If only one item in output_stack, return it directly
+        if len(output_stack) == 1:
+            return output_stack[0]
+        return {
+            "operator": "AND",
+            "conditions": output_stack,
+        }  # Default to AND if no operators
+
+    def to_q(self, parsed_tree: Dict) -> Q:
+        """Convert parsed tree structure into Q objects."""
+        if isinstance(parsed_tree, list):
+            # If parsed_tree is a list, combine all conditions with AND by default
+            q_objects = [self.to_q(cond) for cond in parsed_tree]
+            combined_q = Q()
+            for q_obj in q_objects:
+                combined_q &= q_obj
+            return combined_q
+
+        if isinstance(parsed_tree, dict):
+            if "field_lookup" in parsed_tree:
+                # Base case: a single condition
+                return Q(**{parsed_tree["field_lookup"]: parsed_tree["value"]})
+
+            elif "operator" in parsed_tree and "conditions" in parsed_tree:
+                operator = parsed_tree["operator"]
+                conditions = parsed_tree["conditions"]
+
+                q_objects = [self.to_q(cond) for cond in conditions]
+
+                if operator == "AND":
+                    combined_q = Q()
+                    for q_obj in q_objects:
+                        combined_q &= q_obj
+                    return combined_q
+                elif operator == "OR":
+                    combined_q = Q()
+                    for q_obj in q_objects:
+                        combined_q |= q_obj
+                    return combined_q
+                else:
+                    raise ValueError(f"Unknown operator: {operator}")
+
+        raise ValueError("Parsed tree structure is invalid")
+
+    def parse_to_q(self) -> Q:
+        """Parse the query and convert to Q object."""
+        parsed_tree = self.parse()
+        if not parsed_tree:
+            return Q()  # Return an empty Q if parsing fails
+        return self.to_q(parsed_tree)
+
+    @property
+    def db_query(self) -> Q:
+        if self.__db_query is None:
+            self.__db_query = self.parse_to_q()
+        return self.__db_query
+
+    def __str__(self) -> str:
+        return f"ConditionParser({self.db_query})"