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

camomilla/serializers/mixins/filter_fields.py

@@ -0,0 +1,56 @@
+from rest_framework import serializers
+from camomilla.serializers.fields.related import RelatedField
+from collections import defaultdict
+
+
+class FilterFieldsMixin(serializers.ModelSerializer):
+    """
+    Mixin to filter fields from a serializer, including handling nested fields.
+    """
+    
+    def __init__(self, *args, **kwargs):
+        self.inherited_fields_filter = kwargs.pop("inherited_fields_filter", [])
+        return super().__init__(*args, **kwargs)
+        
+
+    inherited_fields_filter = []
+
+
+    def get_default_field_names(self, *args):
+        field_names = super().get_default_field_names(*args)
+        request = self.context.get("request", None)
+
+        if request is not None and request.method == "GET":
+            fields = request.query_params.get("fields", "").split(",")
+            fields = [f for f in fields if f != ""]
+            if len(self.inherited_fields_filter) > 0:
+                fields = self.inherited_fields_filter
+
+            self.filtered_fields = set()
+            self.childs_fields = defaultdict(set)
+            for field in fields:
+                if "__" in field:
+                    parent_field, child_field = field.split("__", 1)
+                    if parent_field in field_names:
+                        self.filtered_fields.add(parent_field)
+                        self.childs_fields[parent_field].add(child_field)
+
+                        
+                else:
+                    if field in field_names:
+                        self.filtered_fields.add(field)
+
+            if len(self.filtered_fields) > 0:
+                return list(self.filtered_fields)
+            else:
+                return field_names
+
+        return field_names
+
+    def build_field(self, field_name, info, model_class, nested_depth):
+        field_class, field_kwargs = super().build_field(field_name, info, model_class, nested_depth)
+        inherited_fields_filter = self.childs_fields.get(field_name, []) if hasattr(self, "childs_fields") else []
+        if len(inherited_fields_filter) > 0 and issubclass(field_class, RelatedField):
+            field_kwargs["inherited_fields_filter"] = list(inherited_fields_filter)
+        return field_class, field_kwargs
+        

camomilla/serializers/utils.py

@@ -1,6 +1,7 @@
 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,
@@ -10,12 +11,13 @@ def get_standard_bases() -> tuple:
     )
 
     return (
+        SetupEagerLoadingMixin,
+        FilterFieldsMixin,
         NestMixin,
         FieldsOverrideMixin,
         JSONFieldPatchMixin,
         OrderingMixin,
         RemoveTranslationsMixin,
-        SetupEagerLoadingMixin,
         ModelSerializer,
     )
 

camomilla/serializers/validators.py

@@ -8,7 +8,7 @@ from camomilla.utils.translation import get_nofallbacks, set_nofallbacks
 
 
 class UniquePermalinkValidator:
-    message = _("This slug generates a non-unique permalink.")
+    message = _("There is an other page with same permalink.")
 
     requires_context = True
 
@@ -29,13 +29,17 @@ class UniquePermalinkValidator:
             instance, parent_page_field, None
         )
         for language in activate_languages():
-            f_name = build_localized_fieldname("slug", language)
-            slug = value.get(f_name, instance and get_nofallbacks(instance, "slug"))
+            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 = UrlNode.sanitize_permalink(permalink)
+            autopermalink = value.get(autopermalink_f, instance and get_nofallbacks(instance, "autopermalink"))
+            if autopermalink:
+                continue
             fake_instance = serializer.Meta.model()
-            set_nofallbacks(fake_instance, "slug", slug)
+            set_nofallbacks(fake_instance, "permalink", permalink)
             if parent_page:
                 set_nofallbacks(fake_instance, parent_page_field, parent_page)
-            permalink = fake_instance.generate_permalink(safe=False)
             qs = UrlNode.objects.exclude(**exclude_kwargs)
             if qs.filter(permalink=permalink).exists():
                 errors[f_name] = self.message

camomilla/settings.py

@@ -79,10 +79,6 @@ TEMPLATE_CONTEXT_FILES = pointed_getter(
     django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
 )
 
-STRUCTURED_FIELD_CACHE_ENABLED = pointed_getter(
-    django_settings, "CAMOMILLA.STRUCTURED_FIELD.CACHE_ENABLED", True
-)
-
 DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
 
 # camomilla settings example

camomilla/storages/default.py

@@ -0,0 +1,6 @@
+from django.utils.module_loading import import_string
+from django.conf import settings
+
+
+def get_default_storage_class():
+    return import_string(settings.STORAGES["default"]["BACKEND"])

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.link.url }}{% if is_preview %}?preview=true{% endif %}">{{ item.title }}</a>
     {% else %}
       <span>{{item.title}}</span>
     {% endif %}

camomilla/theme/__init__.py

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

camomilla/theme/admin.py

@@ -26,7 +26,7 @@ class UserProfileAdmin(admin.ModelAdmin):
 class ArticleAdminForm(forms.ModelForm):
     class Meta:
         model = Article
-        exclude = ("slug",)
+        fields = "__all__"
         widgets = {"content": CKEditorUploadingWidget}
 
 

camomilla/translation.py

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

camomilla/utils/query_parser.py

@@ -0,0 +1,148 @@
+import re
+from django.db.models import Q
+
+CONDITION_PATTERN = re.compile(r"(\w+__\w+='[^']+'|\w+__\w+=\S+)")  # Updated regex to handle quoted values
+LOGICAL_OPERATORS = {"AND", "OR"}
+
+class ConditionParser:
+    def __init__(self, query):
+        self.query = query
+    
+    def parse(self, query=None):
+        """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):
+        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 = 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):
+        """Parse a single condition into field lookup and value."""
+        if '=' in condition_str:
+            field_lookup, value = condition_str.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):
+        """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 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):
+        """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):
+        """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)

camomilla/utils/setters.py

@@ -0,0 +1,37 @@
+from typing import Sequence
+from .getters import pointed_getter
+
+
+def set_key(data, key, val):
+    if isinstance(data, Sequence):
+        key = int(key)
+        if key < len(data):
+            data[key] = val
+        else:
+            data.append(val)
+        return data
+    elif isinstance(data, dict):
+        data[key] = val
+    else:
+        setattr(data, key, val)
+    return data
+
+
+def get_key(data, key, default):
+    if isinstance(data, Sequence):
+        try:
+            return data[int(key)]
+        except IndexError:
+            return default
+    return pointed_getter(data, key, default)
+
+
+def pointed_setter(data, path, value):
+    path = path.split(".")
+    key = path.pop(0)
+    if not len(path):
+        return set_key(data, key, value)
+    default = [] if path[0].isdigit() else {}
+    return set_key(
+        data, key, pointed_setter(get_key(data, key, default), ".".join(path), value)
+    )

camomilla/views/base/__init__.py

@@ -1,8 +1,8 @@
-from ..mixins import OptimViewMixin, PaginateStackMixin, OrderingMixin
+from ..mixins import OptimViewMixin, PaginateStackMixin, OrderingMixin, CamomillaBasePermissionMixin
 from rest_framework import viewsets
 
 
 class BaseModelViewset(
-    OptimViewMixin, OrderingMixin, PaginateStackMixin, viewsets.ModelViewSet
+    CamomillaBasePermissionMixin, OptimViewMixin, OrderingMixin, PaginateStackMixin, viewsets.ModelViewSet
 ):
     pass

camomilla/views/menus.py

@@ -13,8 +13,6 @@ from camomilla.serializers.page import BasicUrlNodeSerializer
 from camomilla.views.base import BaseModelViewset
 from camomilla.views.decorators import active_lang
 
-from django.utils.translation import get_language
-
 
 class MenuViewSet(BaseModelViewset):
     queryset = Menu.objects.all()
@@ -80,5 +78,4 @@ class MenuViewSet(BaseModelViewset):
     def search_urlnode(self, request, *args, **kwargs):
         url_node = request.GET.get("q", "")
         qs = UrlNode.objects.filter(permalink__icontains=url_node).order_by("permalink")
-        print(get_language())
         return Response(BasicUrlNodeSerializer(qs, many=True).data)

camomilla/views/mixins/__init__.py

@@ -30,9 +30,16 @@ class GetUserLanguageMixin(object):
         return super().initialize_request(request, *args, **kwargs)
 
     def get_queryset(self):
+        if hasattr(super(), "get_queryset"):
+            return super().get_queryset()
         return self.model.objects.all()
 
 
+class CamomillaBasePermissionMixin:
+    def get_permissions(self):
+        return [*super().get_permissions(), CamomillaBasePermissions()]
+
+
 class OptimViewMixin:
     def get_serializer_class(self):
         if hasattr(self, "action_serializers"):
@@ -46,8 +53,8 @@ class OptimViewMixin:
     def get_queryset(self):
         queryset = super().get_queryset()
         serializer = self.get_serializer_class()
-        if hasattr(serializer, "setup_eager_loading"):
-            queryset = self.get_serializer_class().setup_eager_loading(queryset)
+        if hasattr(serializer, "optimize_qs"):
+            queryset = serializer.optimize_qs(queryset, context=self.get_serializer_context())
         return queryset
 
 

camomilla/views/mixins/pagination.py

@@ -2,6 +2,7 @@ from rest_framework.response import Response
 from django.db.models import Q
 from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
 from django.contrib.postgres.search import SearchVector, SearchQuery, TrigramSimilarity
+from camomilla.utils.query_parser import ConditionParser
 
 
 class TrigramSearchMixin:
@@ -32,18 +33,9 @@ class PaginateStackMixin:
             list_handler, "shared_model", getattr(list_handler, "model", None)
         )
 
-    def parse_qs_value(self, string: str):
-        if string and string.startswith("[") and string.endswith("]"):
-            string = [self.parse_qs_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 parse_filter(self, filter):
-        filter_name, value = filter.split("=")
-        return filter_name, self.parse_qs_value(value)
+        parser = ConditionParser(filter)
+        return parser.parse_to_q()
 
     def handle_pagination(self, list_handler=None, items_per_page=None):
         list_handler = list_handler if list_handler is not None else self.get_queryset()
@@ -84,8 +76,7 @@ class PaginateStackMixin:
         filters = dict(self.request.GET).get("fltr", [])
         for filter in filters:
             try:
-                filter_name, value = self.parse_filter(filter)
-                list_handler = list_handler.filter(**{filter_name: value})
+                list_handler = list_handler.filter(self.parse_filter(filter))
             except Exception:
                 pass
         return list_handler

{django_camomilla_cms-6.0.0b14.dist-info → django_camomilla_cms-6.0.0b16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-camomilla-cms
-Version: 6.0.0b14
+Version: 6.0.0b16
 Summary: Django powered cms
 Author-email: Lotrèk <dimmitutto@lotrek.it>
 License: MIT
@@ -20,10 +20,9 @@ Requires-Dist: djangorestframework <4.0.0,>=3.10.0
 Requires-Dist: django-admin-interface <1.0.0,>=0.26.0
 Requires-Dist: Pillow <10.0.0,>=6.2.0
 Requires-Dist: django-ckeditor <7.0.0,>=5.7.1
+Requires-Dist: django-structured-json-field ==0.2.0
 Requires-Dist: python-magic <0.5,>=0.4
-Requires-Dist: django-jsonform ~=2.19.0
 Requires-Dist: Django >=3.2
-Requires-Dist: pydantic ~=2.2.1
 
 # camomilla django cms [![PyPI](https://img.shields.io/pypi/v/django-camomilla-cms?style=flat-square)](https://pypi.org/project/django-camomilla-cms) ![Codecov](https://img.shields.io/codecov/c/github/lotrekagency/camomilla?style=flat-square) ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/lotrekagency/camomilla/Test,%20Coverage%20and%20Release?style=flat-square) [![GitHub](https://img.shields.io/github/license/lotrekagency/camomilla?style=flat-square)](./LICENSE)