django-camomilla-cms 5.8.5__tar.gz → 6.0.0__tar.gz

django_camomilla_cms-6.0.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: django-camomilla-cms
+Version: 6.0.0
+Summary: Django powered cms
+Author-email: Lotrèk <dimmitutto@lotrek.it>
+License: MIT
+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.13,>=3.8
+Description-Content-Type: text/markdown
+License-File: 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.2
+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
+
+[![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) [![License](https://img.shields.io/github/license/camomillacms/camomilla-core?style=flat-square)](./LICENSE)
+
+<br>
+<br>
+<br>
+<br>
+<div align="center">
+    <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="https://camomillacms.github.io/camomilla-core/images/camomilla-logo-dark.svg?v=1">
+        <source media="(prefers-color-scheme: light)" srcset="https://camomillacms.github.io/camomilla-core/images/camomilla-logo-light.svg?v=1">
+        <img alt="Fallback image description" src="https://camomillacms.github.io/camomilla-core/images/camomilla-logo-light.svg?v=1" style="width: 250px; height: auto;">
+    </picture>
+</div>
+<h3 align="center"">Our beloved Django CMS</h3>
+<br>
+
+## ⭐️ Features
+
+<!-- Highlight some of the features your module provide here -->
+
+- 🧘‍♀️ &nbsp;Built on top of the django framework
+- 🥨 &nbsp;Beaked page abstract model to let you manage everything you need as a page.
+- 🏞️ &nbsp;Optimized media management with autoresize
+- 👯 &nbsp;Enable relations inside django JSONFields
+- ⚡️ &nbsp;AutoCreate api endpoints from models
+- 🚧 &nbsp;Enable JsonSchema directly in models endpoints
+
+Camomilla is a Django CMS that allows you to create and manage your website's content with ease. It provides a simple and intuitive interface for managing pages, media, and other content types. Camomilla is built on top of the Django framework, which means it inherits all the features and benefits of Django framework.
+We try to continuously improve Camomilla by adding new features and fixing bugs. You can check the [CHANGELOG](./CHANGELOG.md) to see what has been added in the latest releases.
+
+## 📦 Quick Start
+
+Here you can find some quick setup instructions to get started with Camomilla. For more detailed information, please refer to the [documentation](https://camomillacms.github.io/camomilla-core/).
+
+> [!TIP]
+>
+> #### Env Virtualization 👾
+>
+> Use a virtualenv to isolate your project's dependencies from the system's python installation before starting. Check out [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/) for more information.
+
+Install django-camomilla-cms and django from pip
+
+```bash
+$ pip install django
+$ pip install django-camomilla-cms==6.0.0
+```
+
+Create a new django project
+
+```bash
+$ django-admin startproject <project_name>
+$ cd <project_name>
+```
+
+Create a dedicated folder for camomilla migrations
+
+```bash
+$ mkdir -p camomilla_migrations
+$ touch camomilla_migrations.__init__.py
+```
+
+Create migrations and prepare the database
+
+```bash
+$ python manage.py makemigrations camomilla
+$ python manage.py migrate
+```
+
+Add camomilla and camomilla dependencies to your project's INSTALLED_APPS
+
+```python
+# <project_name>/settings.py
+
+INSTALLED_APPS = [
+    ...
+    'camomilla', # always needed
+    'camomilla.theme', # needed to customize admin interface
+    'djsuperadmin', # needed if you whant to use djsuperadmin for contents
+    'modeltranslation', # needed if your website is multilanguage (can be added later)
+    'rest_framework',  # always needed
+    'rest_framework.authtoken',  # always needed
+    ...
+]
+```
+
+Run the server
+
+```bash
+$ python manage.py runserver
+```
+
+## 🧑‍💻 How to Contribute
+
+We welcome contributions to Camomilla! If you want to contribute, please read our [contributing guide](./CONTRIBUTING.md) for more information on how to get started.

django_camomilla_cms-6.0.0/README.md

@@ -0,0 +1,94 @@
+[![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) [![License](https://img.shields.io/github/license/camomillacms/camomilla-core?style=flat-square)](./LICENSE)
+
+<br>
+<br>
+<br>
+<br>
+<div align="center">
+    <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="https://camomillacms.github.io/camomilla-core/images/camomilla-logo-dark.svg?v=1">
+        <source media="(prefers-color-scheme: light)" srcset="https://camomillacms.github.io/camomilla-core/images/camomilla-logo-light.svg?v=1">
+        <img alt="Fallback image description" src="https://camomillacms.github.io/camomilla-core/images/camomilla-logo-light.svg?v=1" style="width: 250px; height: auto;">
+    </picture>
+</div>
+<h3 align="center"">Our beloved Django CMS</h3>
+<br>
+
+## ⭐️ Features
+
+<!-- Highlight some of the features your module provide here -->
+
+- 🧘‍♀️ &nbsp;Built on top of the django framework
+- 🥨 &nbsp;Beaked page abstract model to let you manage everything you need as a page.
+- 🏞️ &nbsp;Optimized media management with autoresize
+- 👯 &nbsp;Enable relations inside django JSONFields
+- ⚡️ &nbsp;AutoCreate api endpoints from models
+- 🚧 &nbsp;Enable JsonSchema directly in models endpoints
+
+Camomilla is a Django CMS that allows you to create and manage your website's content with ease. It provides a simple and intuitive interface for managing pages, media, and other content types. Camomilla is built on top of the Django framework, which means it inherits all the features and benefits of Django framework.
+We try to continuously improve Camomilla by adding new features and fixing bugs. You can check the [CHANGELOG](./CHANGELOG.md) to see what has been added in the latest releases.
+
+## 📦 Quick Start
+
+Here you can find some quick setup instructions to get started with Camomilla. For more detailed information, please refer to the [documentation](https://camomillacms.github.io/camomilla-core/).
+
+> [!TIP]
+>
+> #### Env Virtualization 👾
+>
+> Use a virtualenv to isolate your project's dependencies from the system's python installation before starting. Check out [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/) for more information.
+
+Install django-camomilla-cms and django from pip
+
+```bash
+$ pip install django
+$ pip install django-camomilla-cms==6.0.0
+```
+
+Create a new django project
+
+```bash
+$ django-admin startproject <project_name>
+$ cd <project_name>
+```
+
+Create a dedicated folder for camomilla migrations
+
+```bash
+$ mkdir -p camomilla_migrations
+$ touch camomilla_migrations.__init__.py
+```
+
+Create migrations and prepare the database
+
+```bash
+$ python manage.py makemigrations camomilla
+$ python manage.py migrate
+```
+
+Add camomilla and camomilla dependencies to your project's INSTALLED_APPS
+
+```python
+# <project_name>/settings.py
+
+INSTALLED_APPS = [
+    ...
+    'camomilla', # always needed
+    'camomilla.theme', # needed to customize admin interface
+    'djsuperadmin', # needed if you whant to use djsuperadmin for contents
+    'modeltranslation', # needed if your website is multilanguage (can be added later)
+    'rest_framework',  # always needed
+    'rest_framework.authtoken',  # always needed
+    ...
+]
+```
+
+Run the server
+
+```bash
+$ python manage.py runserver
+```
+
+## 🧑‍💻 How to Contribute
+
+We welcome contributions to Camomilla! If you want to contribute, please read our [contributing guide](./CONTRIBUTING.md) for more information on how to get started.

django_camomilla_cms-6.0.0/camomilla/__init__.py

@@ -0,0 +1,11 @@
+__version__ = "6.0.0"
+
+
+def get_core_apps():
+    return ["rest_framework", "rest_framework.authtoken"]
+
+
+def autodiscover():
+    from camomilla.templates_context.autodiscover import autodiscover_context_files
+
+    autodiscover_context_files()

django_camomilla_cms-6.0.0/camomilla/apps.py

@@ -0,0 +1,16 @@
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+from django.conf import settings
+
+
+class CamomillaConfig(AppConfig):
+    default_auto_field = "django.db.models.AutoField"
+    name = "camomilla"
+
+    def ready(self):
+        migration_modules = getattr(settings, "MIGRATION_MODULES", {})
+        if "camomilla" not in migration_modules:
+            migration_modules["camomilla"] = "camomilla_migrations"
+        setattr(settings, "MIGRATION_MODULES", migration_modules)
+        self.module.autodiscover()

django_camomilla_cms-6.0.0/camomilla/context_processors.py

@@ -0,0 +1,6 @@
+from camomilla.models import Menu
+
+
+def MenusContextProcessor(request):
+    qs = Menu.objects.all()
+    return {"menus": Menu.defaultdict(**{m.key: m for m in qs})}

django_camomilla_cms-6.0.0/camomilla/contrib/modeltranslation/hvad_migration.py

@@ -0,0 +1,126 @@
+from django.conf import settings
+from django.db import migrations, connection
+
+
+class KeepTranslationsMixin:
+    """
+    This mixin make it possible to keep translations when migrating from django-hvad to modeltranslation and viceversa.
+    To use it, you have to add a dictionary to your migration class called "keep_translations".
+    The dictionary must have model paths as keys and a list of fields to keep as values.
+
+
+    Example:
+    ```python
+    class Migration(KeepTranslationsMixin, migrations.Migration):
+        keep_translations = {
+            "app.Model": ("field1", "field2", "field3")
+        }
+    ```
+    """
+
+    _saved_data_from_plain = {}
+    language_codes = dict(getattr(settings, "LANGUAGES", {})).keys()
+
+    def is_operation_legit(self, o):
+        return not (
+            isinstance(o, migrations.RemoveField)
+            and o.name == "master"
+            and o.model_name.endswith("translation")
+        )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.operations = [o for o in self.operations if self.is_operation_legit(o)]
+        self.operations.insert(
+            0, migrations.RunPython(self._getDataFromHvad, self._restoreDataToHvad)
+        )
+        self.operations.append(
+            migrations.RunPython(
+                self._restoreDataToModelTranslation, self._getDataFromModelTranslation
+            )
+        )
+
+    def _getDataFromHvad(self, apps, schemaeditor):
+        for modelPath, fields in self.keep_translations.items():
+            Model = apps.get_model(*modelPath.split("."))
+            table = Model._meta.db_table + "_translation"
+            if "language_code" not in fields:
+                fields = ("language_code",) + fields
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT master_id FROM {0};".format(table))
+                masters = list(set(cursor.fetchall()))
+                for master in masters:
+                    cursor.execute(
+                        "SELECT {0} FROM {1} WHERE master_id={2};".format(
+                            ",".join(fields), table, master[0]
+                        )
+                    )
+                    rows = cursor.fetchall()
+                    self._saved_data_from_plain[modelPath] = (
+                        self._saved_data_from_plain.get(modelPath, {})
+                    )
+                    self._saved_data_from_plain[modelPath][master[0]] = (
+                        self._saved_data_from_plain[modelPath].get(master[0], [])
+                    )
+                    for row in rows:
+                        self._saved_data_from_plain[modelPath][master[0]].append(
+                            dict(zip(fields, row))
+                        )
+
+    def _getDataFromModelTranslation(self, apps, schemaeditor):
+        for modelPath, fields in self.keep_translations.items():
+            Model = apps.get_model(*modelPath.split("."))
+            table = Model._meta.db_table
+            for lang in self.language_codes:
+                t_fields = ("id",) + tuple(
+                    "{0}_{1}".format(f, lang) for f in fields if f != "id"
+                )
+                with connection.cursor() as cursor:
+                    cursor.execute(
+                        "SELECT {0} FROM {1}".format(
+                            ",".join(t_fields),
+                            table,
+                        )
+                    )
+                    rows = cursor.fetchall()
+                    self._saved_data_from_plain[modelPath] = (
+                        self._saved_data_from_plain.get(modelPath, [])
+                    )
+                    for row in rows:
+                        row_data = dict(zip(("master_id", *fields), row))
+                        row_data.update({"language_code": lang})
+                        self._saved_data_from_plain[modelPath].append(row_data)
+
+    def _restoreDataToModelTranslation(self, apps, schemaeditor):
+        for key, master_dict in self._saved_data_from_plain.items():
+            Model = apps.get_model(*key.split("."))
+            for pk, translations in master_dict.items():
+                try:
+                    obj = Model.objects.get(pk=pk)
+                except Model.DoesNotExist:
+                    continue
+                for translation in translations:
+                    lang = translation.pop("language_code")
+                    for attr, value in translation.items():
+                        setattr(obj, "{0}_{1}".format(attr, lang), value)
+                obj.save()
+
+    def _restoreDataToHvad(self, apps, schemaeditor):
+        for key, rows in self._saved_data_from_plain.items():
+            Model = apps.get_model(*key.split("."))
+            table = Model._meta.db_table + "_translation"
+            for row in rows:
+                with connection.cursor() as cursor:
+                    print(row)
+                    cursor.execute(
+                        "INSERT INTO {0} ({1}) VALUES ({2});".format(
+                            table,
+                            ",".join(row.keys()),
+                            ",".join(
+                                [
+                                    "'{}'".format(v).replace("'None'", "NULL")
+                                    for v in row.values()
+                                ]
+                            ),
+                        )
+                    )

django_camomilla_cms-6.0.0/camomilla/dynamic_pages_urls.py

@@ -0,0 +1,33 @@
+from django.shortcuts import redirect, render
+from django.urls import path
+
+from camomilla import settings
+from django.conf import settings as django_settings
+from .models import Page, UrlRedirect
+
+
+def fetch(request, *args, **kwargs):
+    can_preview = request.user.is_staff or settings.DEBUG
+    preview = can_preview and request.GET.get("preview", False)
+    append_slash = getattr(django_settings, "APPEND_SLASH", True)
+    redirect_obj = UrlRedirect.find_redirect(request)
+    if redirect_obj:
+        return redirect_obj.redirect()
+    if append_slash and not request.path.endswith("/"):
+        q_string = request.META.get("QUERY_STRING", "")
+        return redirect(request.path + "/" + ("?" + q_string if q_string else ""))
+    if "permalink" in kwargs:
+        page = Page.get_or_404(
+            request, bypass_public_check=preview, bypass_type_check=True
+        )
+    elif settings.AUTO_CREATE_HOMEPAGE is False:
+        page, _ = Page.get_or_404(permalink="/", bypass_type_check=True)
+    else:
+        page, _ = Page.get_or_create_homepage()
+    return render(request, page.get_template_path(request), page.get_context(request))
+
+
+urlpatterns = [
+    path("", fetch, name="camomilla-homepage"),
+    path("<path:permalink>", fetch, name="camomilla-permalink"),
+]

django_camomilla_cms-6.0.0/camomilla/fields/__init__.py

@@ -0,0 +1,13 @@
+from django.db import models
+
+from .json import ArrayField, JSONField
+
+ORDERING_ACCEPTED_FIELDS = (
+    models.BigIntegerField,
+    models.IntegerField,
+    models.PositiveIntegerField,
+    models.PositiveSmallIntegerField,
+    models.SmallIntegerField,
+)
+
+__all__ = ["JSONField", "ArrayField", "ORDERING_ACCEPTED_FIELDS"]

django-camomilla-cms-5.8.5/camomilla/fields.py → django_camomilla_cms-6.0.0/camomilla/fields/json.py

@@ -1,32 +1,18 @@
 import json
+
 import django
 from django.conf import settings
+
 if django.VERSION >= (4, 0):
     from django.db.models import JSONField as DjangoJSONField
 else:
     from django.contrib.postgres.fields import JSONField as DjangoJSONField
+
 from django.contrib.postgres.fields import ArrayField as DjangoArrayField
 from django.db import models
 
 
-ORDERING_ACCEPTED_FIELDS = (
-    models.BigIntegerField,
-    models.IntegerField,
-    models.PositiveIntegerField,
-    models.PositiveSmallIntegerField,
-    models.SmallIntegerField,
-)
-
-
-class JSONField(DjangoJSONField):
-    pass
-
-
-class ArrayField(DjangoArrayField):
-    pass
-
-
-if "sqlite" in settings.DATABASES["default"]["ENGINE"]:
+if "sqlite" in settings.DATABASES["default"]["ENGINE"]:  # noqa: C901
 
     class JSONField(models.Field):
         def db_type(self, connection):
@@ -70,3 +56,14 @@ if "sqlite" in settings.DATABASES["default"]["ENGINE"]:
                 }
             )
             return name, path, args, kwargs
+
+else:
+
+    class JSONField(DjangoJSONField):
+        pass
+
+    class ArrayField(DjangoArrayField):
+        pass
+
+
+__all__ = [JSONField, ArrayField]

{django-camomilla-cms-5.8.5 → django_camomilla_cms-6.0.0}/camomilla/management/commands/regenerate_thumbnails.py

@@ -3,7 +3,6 @@ from camomilla.models import Media
 
 
 class Command(BaseCommand):
-
     help = "Regenerates all the thumbnail"
 
     def handle(self, *args, **options):

django_camomilla_cms-6.0.0/camomilla/managers/__init__.py

@@ -0,0 +1,3 @@
+from .pages import PageQuerySet
+
+__all__ = ["PageQuerySet"]

django_camomilla_cms-6.0.0/camomilla/managers/pages.py

@@ -0,0 +1,116 @@
+from django.db.models.query import QuerySet
+from django.core.exceptions import ObjectDoesNotExist
+from django.apps import apps
+from django.db import models
+from django.utils import timezone
+from django.db.utils import ProgrammingError, OperationalError
+from typing import Sequence, Tuple
+
+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
+
+    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}
+                )
+                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)
+
+
+class UrlNodeManager(models.Manager):
+    @property
+    def related_names(self):
+        self._related_names = getattr(
+            self,
+            "_related_names",
+            super().get_queryset().values_list("related_name", flat=True).distinct(),
+        )
+        return self._related_names
+
+    def _annotate_fields(
+        self,
+        qs: models.QuerySet,
+        field_names: Sequence[Tuple[str, models.Field, models.Value]],
+    ):
+        for field_name, output_field, default in field_names:
+            whens = [
+                models.When(
+                    related_name=related_name,
+                    then=models.F("__".join([related_name, field_name])),
+                )
+                for related_name in self.related_names
+            ]
+            qs = qs.annotate(
+                **{
+                    field_name: models.Case(
+                        *whens, output_field=output_field, default=default
+                    )
+                }
+            )
+        return self._annotate_is_public(qs)
+
+    def _annotate_is_public(self, qs: models.QuerySet):
+        return qs.annotate(
+            is_public=models.Case(
+                models.When(status="PUB", then=True),
+                models.When(
+                    status="PLA", publication_date__lte=timezone.now(), then=True
+                ),
+                default=False,
+                output_field=models.BooleanField(default=False),
+            )
+        )
+
+    def get_queryset(self):
+        try:
+            return self._annotate_fields(
+                super().get_queryset(),
+                [
+                    (
+                        "indexable",
+                        models.BooleanField(),
+                        models.Value(None, models.BooleanField()),
+                    ),
+                    (
+                        "status",
+                        models.CharField(),
+                        models.Value("DRF", models.CharField()),
+                    ),
+                    (
+                        "publication_date",
+                        models.DateTimeField(),
+                        models.Value(timezone.now(), models.DateTimeField()),
+                    ),
+                    (
+                        "date_updated_at",
+                        models.DateTimeField(),
+                        models.Value(timezone.now(), models.DateTimeField()),
+                    ),
+                ],
+            )
+        except (ProgrammingError, OperationalError):
+            return super().get_queryset()