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

camomilla/utils/query_parser.py

@@ -1,14 +1,21 @@
 import re
 from django.db.models import Q
+from typing import List, Dict, Optional
 
-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):
+    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=None):
+
+    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
@@ -19,31 +26,31 @@ class ConditionParser:
             return tokens[0]
         return self.build_tree(tokens)
 
-    def tokenize(self, query):
+    def tokenize(self, query: str) -> List:
         tokens = []
         i = 0
         while i < len(query):
-            if query[i] == '(':
+            if query[i] == "(":
                 j = i + 1
                 open_parens = 1
                 while j < len(query) and open_parens > 0:
-                    if query[j] == '(':
+                    if query[j] == "(":
                         open_parens += 1
-                    elif query[j] == ')':
+                    elif query[j] == ")":
                         open_parens -= 1
                     j += 1
                 if open_parens == 0:
-                    subquery = query[i + 1:j - 1]
+                    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'
+            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
+                i += 3 if operator == "AND" else 2
             else:
-                match = CONDITION_PATTERN.match(query[i:])
+                match = self.CONDITION_PATTERN.match(query[i:])
                 if match:
                     condition = self.parse_condition(match.group())
                     tokens.append(condition)
@@ -52,10 +59,10 @@ class ConditionParser:
                     i += 1
         return tokens
 
-    def parse_condition(self, condition_str):
+    def parse_condition(self, condition: str) -> Optional[Dict]:
         """Parse a single condition into field lookup and value."""
-        if '=' in condition_str:
-            field_lookup, value = condition_str.split("=")
+        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}
@@ -71,7 +78,7 @@ class ConditionParser:
             string = int(string)
         return string
 
-    def build_tree(self, tokens):
+    def build_tree(self, tokens: List[str]) -> Dict:
         """Build a tree-like structure with operators and conditions."""
         if not tokens:
             return None
@@ -88,23 +95,26 @@ class ConditionParser:
                     if isinstance(output_stack[-1], dict):
                         output_stack[-1] = {
                             "operator": operator,
-                            "conditions": [output_stack[-1], token]
+                            "conditions": [output_stack[-1], token],
                         }
                     else:
                         output_stack[-1]["conditions"].append(token)
                 else:
                     output_stack.append(token)
 
-            elif token in LOGICAL_OPERATORS:
+            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
+        return {
+            "operator": "AND",
+            "conditions": output_stack,
+        }  # Default to AND if no operators
 
-    def to_q(self, parsed_tree):
+    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
@@ -140,9 +150,18 @@ class ConditionParser:
 
         raise ValueError("Parsed tree structure is invalid")
 
-    def parse_to_q(self):
+    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})"

camomilla/utils/templates.py

@@ -3,18 +3,31 @@ from typing import Sequence
 
 from django import template as django_template
 from os.path import relpath
+from camomilla.settings import REGISTERED_TEMPLATES_APPS
 
 
 def get_all_templates_files() -> Sequence[str]:
-    dirs = []
-    for engine in django_template.loader.engines.all():
-        # Exclude pip installed site package template dirs
-        dirs.extend(
-            x
-            for x in engine.template_dirs
-            if "site-packages" not in str(x) or "camomilla" in str(x)
-        )
     files = []
-    for dir in dirs:
-        files.extend(relpath(x, dir) for x in Path(dir).glob("**/*.html") if x)
+
+    for engine in django_template.loader.engines.all():
+
+        if REGISTERED_TEMPLATES_APPS:
+            dirs = [
+                d for d in engine.template_dirs
+                if any(app in str(d) for app in REGISTERED_TEMPLATES_APPS)
+            ]
+        else:
+            # Exclude pip installed site package template dirs
+            dirs = [
+                d for d in engine.template_dirs
+                if "site-packages" not in str(d) or "camomilla" in str(d)
+            ]
+
+        for d in dirs:
+            base = Path(d)
+            files.extend(
+                relpath(f, d)
+                for f in base.rglob("*.html")
+            )
+
     return files

camomilla/utils/translation.py

@@ -1,11 +1,12 @@
 import re
-from typing import Any, Sequence, Iterator
+from typing import Any, Sequence, Iterator, Union, List
 
 from django.db.models import Model, Q
 from django.utils.translation.trans_real import activate, get_language
 from modeltranslation.settings import AVAILABLE_LANGUAGES, DEFAULT_LANGUAGE
 from modeltranslation.utils import build_localized_fieldname
 from camomilla.settings import BASE_URL
+from django.http import QueryDict
 
 
 def activate_languages(languages: Sequence[str] = AVAILABLE_LANGUAGES) -> Iterator[str]:
@@ -34,11 +35,9 @@ def get_nofallbacks(instance: Model, attr: str, *args, **kwargs) -> Any:
 
 def url_lang_decompose(url):
     if BASE_URL and url.startswith(BASE_URL):
-        url = url[len(BASE_URL):]
+        url = url[len(BASE_URL) :]
     data = {"url": url, "permalink": url, "language": DEFAULT_LANGUAGE}
-    result = re.match(
-        f"^\/?({'|'.join(AVAILABLE_LANGUAGES)})?\/(.*)", url
-    )  # noqa: W605
+    result = re.match(rf"^/?({'|'.join(AVAILABLE_LANGUAGES)})?/(.*)", url)  # noqa: W605
     groups = result and result.groups()
     if groups and len(groups) == 2:
         data["language"] = groups[0]
@@ -70,3 +69,46 @@ def is_translatable(model: Model) -> bool:
     from modeltranslation.translator import translator
 
     return model in translator.get_registered_models()
+
+
+def plain_to_nest(data, fields, accessor="translations"):
+    """
+    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 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="translations"
+):
+    """
+    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 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 == DEFAULT_LANGUAGE:
+                    data[k] = nest_trans[k]
+                key = build_localized_fieldname(k, lang)
+                data[key] = data.get(key, nest_trans[k])
+    return data

camomilla/views/base/__init__.py

@@ -1,8 +1,38 @@
-from ..mixins import OptimViewMixin, PaginateStackMixin, OrderingMixin, CamomillaBasePermissionMixin
+from ..mixins import (
+    OptimViewMixin,
+    PaginateStackMixin,
+    OrderingMixin,
+    CamomillaBasePermissionMixin,
+)
 from rest_framework import viewsets
+from rest_framework.metadata import SimpleMetadata
+from structured.contrib.restframework import StructuredJSONField
 
 
-class BaseModelViewset(
-    CamomillaBasePermissionMixin, OptimViewMixin, OrderingMixin, PaginateStackMixin, viewsets.ModelViewSet
-):
-    pass
+base_viewset_classes = [
+    CamomillaBasePermissionMixin,
+    OptimViewMixin,
+    OrderingMixin,
+    PaginateStackMixin,
+    viewsets.ModelViewSet,
+]
+
+
+class BaseViewMetadata(SimpleMetadata):
+
+    def get_field_info(self, field):
+        field_info = super().get_field_info(field)
+        if isinstance(field, StructuredJSONField):
+            field_info["schema"] = field.schema.json_schema()
+            field_info["type"] = "structured-json"
+        return field_info
+
+    def get_serializer_info(self, serializer):
+        info = super().get_serializer_info(serializer)
+        if hasattr(serializer, "plain_to_nest"):
+            info.update(serializer.plain_to_nest(info))
+        return info
+
+
+class BaseModelViewset(*base_viewset_classes):
+    metadata_class = BaseViewMetadata

camomilla/views/medias.py

@@ -61,7 +61,7 @@ class MediaFolderViewSet(
         ).data
         media_data = self.format_output(
             *self.handle_pagination_stack(media_queryset),
-            SerializerClass=MediaListSerializer
+            SerializerClass=MediaListSerializer,
         )
         return {
             "folders": folder_data,

camomilla/views/mixins/__init__.py

@@ -1,76 +1,17 @@
-from rest_framework import status
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from .pagination import *
-from .ordering import *
-from ...permissions import CamomillaBasePermissions
-from django.utils import translation
-
-
-class GetUserLanguageMixin(object):
-    def _get_user_language(self, request):
-        self.active_language = request.GET.get(
-            "language",
-            request.GET.get(
-                "language_code", translation.get_language_from_request(request)
-            ),
-        )
-        self.language_fallbacks = True
-        if (
-            len(self.active_language.split("-")) == 2
-            and self.active_language.split("-")[0] == "nofallbacks"
-        ):
-            self.language_fallbacks = False
-            self.active_language = self.active_language.split("-")[1]
-        translation.activate(self.active_language)
-        return self.active_language
-
-    def initialize_request(self, request, *args, **kwargs):
-        self._get_user_language(request)
-        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"):
-            if self.action in self.action_serializers:
-                return self.action_serializers[self.action]
-        return super().get_serializer_class()
-
-    def get_serializer_context(self):
-        return {"request": self.request, "action": self.action}
-
-    def get_queryset(self):
-        queryset = super().get_queryset()
-        serializer = self.get_serializer_class()
-        if hasattr(serializer, "optimize_qs"):
-            queryset = serializer.optimize_qs(queryset, context=self.get_serializer_context())
-        return queryset
-
-
-class BulkDeleteMixin(object):
-    @action(
-        detail=False, methods=["post"], permission_classes=(CamomillaBasePermissions,)
-    )
-    def bulk_delete(self, request):
-        try:
-            self.model.objects.filter(pk__in=request.data).delete()
-            return Response(
-                {"detail": "Eliminazione multipla andata a buon fine"},
-                status=status.HTTP_200_OK,
-            )
-        except Exception:
-            return Response(
-                {"detail": "Eliminazione multipla non riuscita"},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            )
+from .bulk_actions import BulkDeleteMixin
+from .language import GetUserLanguageMixin
+from .optimize import OptimViewMixin
+from .ordering import OrderingMixin
+from .pagination import PaginateStackMixin, TrigramSearchMixin
+from .permissions import CamomillaBasePermissionMixin
+
+
+__all__ = [
+    "BulkDeleteMixin",
+    "GetUserLanguageMixin",
+    "OptimViewMixin",
+    "OrderingMixin",
+    "PaginateStackMixin",
+    "TrigramSearchMixin",
+    "CamomillaBasePermissionMixin",
+]

camomilla/views/mixins/bulk_actions.py

@@ -0,0 +1,22 @@
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from ...permissions import CamomillaBasePermissions
+
+
+class BulkDeleteMixin(object):
+    @action(
+        detail=False, methods=["post"], permission_classes=(CamomillaBasePermissions,)
+    )
+    def bulk_delete(self, request):
+        try:
+            self.model.objects.filter(pk__in=request.data).delete()
+            return Response(
+                {"detail": "Eliminazione multipla andata a buon fine"},
+                status=status.HTTP_200_OK,
+            )
+        except Exception:
+            return Response(
+                {"detail": "Eliminazione multipla non riuscita"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )

camomilla/views/mixins/language.py

@@ -0,0 +1,33 @@
+from django.utils import translation
+from camomilla import settings
+
+
+class GetUserLanguageMixin:
+    def _get_user_language(self, request):
+        active_language_from_request = translation.get_language_from_request(request)
+        active_language = (
+            active_language_from_request
+            if active_language_from_request
+            else settings.DEFAULT_LANGUAGE
+        )
+        active_language = request.GET.get("language_code", active_language)
+        active_language = request.GET.get("language", active_language)
+        self.active_language = active_language
+        self.language_fallbacks = True
+        if (
+            len(self.active_language.split("-")) == 2
+            and self.active_language.split("-")[0] == "nofallbacks"
+        ):
+            self.language_fallbacks = False
+            self.active_language = self.active_language.split("-")[1]
+        translation.activate(self.active_language)
+        return self.active_language
+
+    def initialize_request(self, request, *args, **kwargs):
+        self._get_user_language(request)
+        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()

camomilla/views/mixins/optimize.py

@@ -0,0 +1,18 @@
+class OptimViewMixin:
+    def get_serializer_class(self):
+        if hasattr(self, "action_serializers"):
+            if self.action in self.action_serializers:
+                return self.action_serializers[self.action]
+        return super().get_serializer_class()
+
+    def get_serializer_context(self):
+        return {"request": self.request, "action": self.action}
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        serializer = self.get_serializer_class()
+        if hasattr(serializer, "optimize_qs"):
+            queryset = serializer.optimize_qs(
+                queryset, context=self.get_serializer_context()
+            )
+        return queryset

camomilla/views/mixins/pagination.py

@@ -3,6 +3,7 @@ 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
+from django.conf import settings
 
 
 class TrigramSearchMixin:
@@ -33,10 +34,6 @@ class PaginateStackMixin:
             list_handler, "shared_model", getattr(list_handler, "model", None)
         )
 
-    def parse_filter(self, filter):
-        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()
         items_per_page = int(
@@ -76,7 +73,7 @@ class PaginateStackMixin:
         filters = dict(self.request.GET).get("fltr", [])
         for filter in filters:
             try:
-                list_handler = list_handler.filter(self.parse_filter(filter))
+                list_handler = list_handler.filter(ConditionParser(filter).db_query)
             except Exception:
                 pass
         return list_handler
@@ -86,9 +83,15 @@ class PaginateStackMixin:
         search_string = self.request.GET.get("search", None)
         search_fields = search_fields or getattr(self, "search_fields", [])
         if search_string and len(search_fields) > 0:
-            return list_handler.annotate(
-                search=SearchVector(*search_fields),
-            ).filter(search=SearchQuery(search_string))
+            if "sqlite" in settings.DATABASES["default"]["ENGINE"]:
+                filter_statement = Q()
+                for field in search_fields:
+                    filter_statement |= Q(**{field + '__icontains': search_string})
+                return list_handler.filter(filter_statement)
+            else:
+                return list_handler.annotate(
+                    search=SearchVector(*search_fields),
+                ).filter(search=SearchQuery(search_string))
 
         return list_handler
 

camomilla/views/mixins/permissions.py

@@ -0,0 +1,6 @@
+from camomilla.permissions import CamomillaBasePermissions
+
+
+class CamomillaBasePermissionMixin:
+    def get_permissions(self):
+        return [*super().get_permissions(), CamomillaBasePermissions()]

camomilla/views/pages.py

@@ -1,13 +1,14 @@
 from camomilla.models import Page
-from camomilla.models.page import UrlNode
+from camomilla.models.page import UrlNode, UrlRedirect
 from camomilla.permissions import CamomillaBasePermissions
 from camomilla.serializers import PageSerializer
 from camomilla.serializers.page import UrlNodeSerializer
 from camomilla.views.base import BaseModelViewset
 from camomilla.views.decorators import active_lang
 from camomilla.views.mixins import BulkDeleteMixin, GetUserLanguageMixin
-from rest_framework.decorators import api_view
+from rest_framework.decorators import api_view, permission_classes
 from rest_framework.response import Response
+from rest_framework import permissions
 from django.shortcuts import get_object_or_404
 
 
@@ -20,6 +21,15 @@ class PageViewSet(GetUserLanguageMixin, BulkDeleteMixin, BaseModelViewset):
 
 @active_lang()
 @api_view(["GET"])
+@permission_classes(
+    [
+        permissions.AllowAny,
+    ]
+)
 def fetch_page(request, permalink=""):
+    redirect = UrlRedirect.find_redirect_from_url(f"/{permalink}")
+    if redirect:
+        redirect = redirect.redirect()
+        return Response({"redirect": redirect.url, "status": redirect.status_code})
     node = get_object_or_404(UrlNode, permalink=f"/{permalink}")
     return Response(UrlNodeSerializer(node, context={"request": request}).data)

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

@@ -1,30 +1,33 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: django-camomilla-cms
-Version: 6.0.0b16
+Version: 6.0.0b18
 Summary: Django powered cms
 Author-email: Lotrèk <dimmitutto@lotrek.it>
 License: MIT
-Project-URL: Homepage, https://github.com/lotrekagency/camomilla
+Project-URL: Homepage, https://github.com/camomillacms/camomilla-core
 Keywords: cms,django,api cms
 Classifier: Environment :: Web Environment
 Classifier: Framework :: Django
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.6
+Requires-Python: <=3.13,>=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: django-modeltranslation ~=0.18.11
-Requires-Dist: djsuperadmin <1.0.0,>=0.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 >=3.2
-
-# 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)
+Requires-Dist: django-modeltranslation<=0.18.12,>=0.18.7
+Requires-Dist: djsuperadmin<1.0.0,>=0.9
+Requires-Dist: djangorestframework<=3.14.0,>=3.10.0
+Requires-Dist: django-structured-json-field>=0.4.1
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: django-admin-interface<1.0.0,>=0.26.0
+Requires-Dist: django-ckeditor<7.0.0,>=5.7.1
+Requires-Dist: django-tinymce<5.0.0,>=4.1.0
+Requires-Dist: python-magic<0.5,>=0.4
+Requires-Dist: Django<6,>=3.2
+Requires-Dist: django_jsonform>=2.23
+Dynamic: license-file
+
+# 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/camomillacms/camomilla-core?style=flat-square) ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/camomillacms/camomilla-core/Test,%20Coverage%20and%20Release?style=flat-square) [![GitHub](https://img.shields.io/github/license/camomillacms/camomilla-core?style=flat-square)](./LICENSE)
 
 ## Install 
 
@@ -35,7 +38,7 @@ $ pip install django-camomilla-cms
 ## Setup 
 ```shell
 $ mkdir -p camomilla_migrations
-$ touch camomilla_migrations.__init__.py
+$ touch camomilla_migrations/__init__.py
 $ python manage.py makemigrations camomilla
 $ python manage.py migrate camomilla
 ```
@@ -70,3 +73,7 @@ INSTALLED_APPS = [
 
     pip install -r requirements-dev.txt
     make test
+
+## Run format with black
+
+    black camomilla