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

camomilla/__init__.py

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

camomilla/managers/pages.py

@@ -6,26 +6,26 @@ 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"])))
-    
+
     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)

camomilla/model_api.py

@@ -26,6 +26,7 @@ def register(
     """
 
     def inner(model):
+        global urlpatterns
         base_meta = {
             "model": model,
             "fields": "__all__",
@@ -46,14 +47,18 @@ 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,
             },
@@ -73,7 +78,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,10 +14,10 @@ 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
+from django.conf import settings
 
 
 class LinkTypes(str, Enum):
@@ -88,7 +88,8 @@ class Menu(models.Model):
     ):
         if isinstance(context, RequestContext):
             context = context.flatten()
-        context.update({"menu": self})
+        is_preview = 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):

camomilla/models/page.py

@@ -36,6 +36,7 @@ from modeltranslation.utils import build_localized_fieldname
 class UrlPathValidator():
     pass
 
+
 def GET_TEMPLATE_CHOICES():
     return [(t, t) for t in get_all_templates_files()]
 
@@ -116,14 +117,13 @@ class UrlNodeManager(models.Manager):
 
 
 class UrlNode(models.Model):
-    
+
     LANG_PERMALINK_FIELDS = [
         build_localized_fieldname("permalink", lang)
         for lang in AVAILABLE_LANGUAGES
         if settings.ENABLE_TRANSLATIONS
     ]
-    
-    
+
     permalink = models.CharField(max_length=400, unique=True, null=True)
     related_name = models.CharField(max_length=200)
     objects = UrlNodeManager()
@@ -153,7 +153,7 @@ class UrlNode(models.Model):
         if self.routerlink == "/":
             return ""
         return self.routerlink
-    
+
     @staticmethod
     def sanitize_permalink(permalink):
         if isinstance(permalink, str):
@@ -162,12 +162,12 @@ class UrlNode(models.Model):
             if not permalink.startswith("/"):
                 permalink = f"/{permalink}"
         return permalink
-    
+
     def save(self, *args, **kwargs) -> None:
         for lang_p_field in UrlNode.LANG_PERMALINK_FIELDS:
             setattr(self, lang_p_field, UrlNode.sanitize_permalink(getattr(self, lang_p_field)))
         super().save(*args, **kwargs)
-        
+
     def __str__(self) -> str:
         return self.permalink
 
@@ -190,10 +190,11 @@ class PageBase(models.base.ModelBase):
     def perm_prop_factory(permalink_field):
         def getter(_self):
             return getattr(_self, f"__{permalink_field}", getattr(_self.url_node or object(), permalink_field, None))
-        def setter(_self, value:str):
+
+        def setter(_self, value: str):
             setattr(_self, f"__{permalink_field}", value)
         return getter, setter
-    
+
     def __new__(cls, name, bases, attrs, **kwargs):
         attr_meta = attrs.pop("PageMeta", None)
         new_class = super().__new__(cls, name, bases, attrs, **kwargs)
@@ -246,7 +247,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
     )
 
     objects = PageQuerySet.as_manager()
-    
+
     __cached_db_instance: "AbstractPage" = None
 
     @property
@@ -254,7 +255,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         if self.__cached_db_instance is None:
             self.__cached_db_instance = self.get_db_instance()
         return self.__cached_db_instance
-    
+
     def get_db_instance(self):
         if self.pk:
             return self.__class__.objects.get(pk=self.pk)
@@ -337,7 +338,7 @@ class AbstractPage(SeoMixin, MetaMixin, models.Model, metaclass=PageBase):
         for __ in activate_languages():
             old_permalink = self.db_instance and self.db_instance.permalink
             new_permalink = self.permalink
-            if self.autopermalink:            
+            if self.autopermalink:
                 new_permalink = self.generate_permalink()
             force = force or old_permalink != new_permalink
             set_nofallbacks(self.url_node, "permalink", new_permalink)

camomilla/openapi/schema.py

@@ -55,4 +55,8 @@ class SchemaGenerator(DRFSchemaGenerator):
     def create_view(self, callback, method, request=None):
         view = super(SchemaGenerator, self).create_view(callback, method, request)
         view.schema = AutoSchema()
+        if not hasattr(view, 'get_queryset') and getattr(view, 'queryset', None) is None:
+            attname = "permission_classes"
+            cname = "DjangoModelPermissions"
+            setattr(view, attname, [p for p in getattr(view, attname, []) if cname not in p.__name__])
         return view

camomilla/serializers/base/__init__.py

@@ -8,14 +8,16 @@ from ..mixins import (
     OrderingMixin,
     SetupEagerLoadingMixin,
 )
+from ..mixins.filter_fields import FilterFieldsMixin
 
 
 class BaseModelSerializer(
+    SetupEagerLoadingMixin,
     NestMixin,
+    FilterFieldsMixin,
     FieldsOverrideMixin,
     JSONFieldPatchMixin,
     OrderingMixin,
-    SetupEagerLoadingMixin,
     TranslationsMixin,
     serializers.ModelSerializer,
 ):

camomilla/serializers/fields/json.py

@@ -9,7 +9,6 @@ if TYPE_CHECKING:
     from structured.pydantic.models import BaseModel
 
 
-
 class StructuredJSONField(serializers.JSONField):
     """
     This field allows to serialize and deserialize structured data.

camomilla/serializers/fields/related.py

@@ -18,6 +18,7 @@ class RelatedField(serializers.PrimaryKeyRelatedField):
     """
 
     def __init__(self, **kwargs):
+        self.inherited_fields_filter = kwargs.pop("inherited_fields_filter", [])
         self.serializer = kwargs.pop("serializer", None)
         self.lookup = kwargs.pop("lookup", "id")
         if self.serializer is not None:
@@ -42,7 +43,10 @@ class RelatedField(serializers.PrimaryKeyRelatedField):
 
     def to_representation(self, instance):
         if self.serializer:
-            return self.serializer(instance, context=self.context).data
+            kwargs = {"context": self.context}
+            if self.inherited_fields_filter:
+                kwargs["inherited_fields_filter"] = self.inherited_fields_filter
+            return self.serializer(instance, **kwargs).data
         return super().to_representation(instance)
 
     def to_internal_value(self, data):

camomilla/serializers/mixins/__init__.py

@@ -57,8 +57,50 @@ class SetupEagerLoadingMixin:
     """
     This mixin allows to use the setup_eager_loading method to optimize the queries.
     """
-    @staticmethod
-    def setup_eager_loading(queryset):
+    
+    @classmethod
+    def optimize_qs(cls, queryset, context=None):
+        if hasattr(cls, "setup_eager_loading"):
+            queryset = cls.setup_eager_loading(queryset, context=context)
+        return cls.auto_optimize_queryset(queryset, context=context)
+    
+    @classmethod
+    def auto_optimize_queryset(cls, queryset, context=None):
+        request = context.get("request", None)
+        if request and request.method == "GET":
+            model = getattr(cls.Meta, "model", None)
+            info = model_meta.get_field_info(model)
+            only = set()
+            prefetch_related = set()
+            select_related = set()
+            serializer_fields = cls(context=context).fields.keys()
+            filtered_fields = set()
+            for field in request.query_params.get("fields", "").split(","):
+                if "__" in field:
+                    field, _ = field.split("__", 1)
+                if field in serializer_fields:
+                    filtered_fields.add(field)
+            if len(filtered_fields) == 0:
+                filtered_fields = serializer_fields
+            for field in filtered_fields:
+                complete_field = field
+                if "__" in field:
+                    field, sub_field = field.split("__", 1)
+                    complete_field = f"{field}__{sub_field}"
+                if field in info.forward_relations and not info.forward_relations[field].to_many:
+                    select_related.add(field)
+                    only.add(complete_field)
+                elif field in info.reverse_relations or field in info.forward_relations and  info.forward_relations[field].to_many:
+                    prefetch_related.add(field)
+                    only.add(complete_field)
+                elif field in info.fields or field == info.pk.name:
+                    only.add(complete_field)
+            if len(only) > 0:
+                queryset = queryset.only(*only)
+            if len(select_related) > 0:
+                queryset = queryset.select_related(*select_related)
+            if len(prefetch_related) > 0:
+                queryset = queryset.prefetch_related(*prefetch_related)
         return queryset
 
 
@@ -174,13 +216,16 @@ class AbstractPageMixin(serializers.ModelSerializer):
 
     def get_default_field_names(self, *args):
         from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
-
+        default_fields = super().get_default_field_names(*args)
+        filtered_fields = getattr(self, "filtered_fields", [])
+        if len(filtered_fields) > 0:
+            return filtered_fields
         if RemoveTranslationsMixin in self.__class__.__bases__:  # noqa: E501
-            return super().get_default_field_names(*args)
+            return default_fields
         return (
-            [f for f in super().get_default_field_names(*args) if f != "url_node"]
+            [f for f in default_fields if f != "url_node"]
             + UrlNode.LANG_PERMALINK_FIELDS
-            + ["permalink"]
+            + ["permalink"] 
         )
 
     def build_field(self, field_name, info, model_class, nested_depth):

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/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.15"
+__version__ = "6.0.0-beta.16"

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

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