django-camomilla-cms 5.8.5__py2.py3-none-any.whl → 6.0.0__py2.py3-none-any.whl

camomilla/__init__.py

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

camomilla/apps.py

@@ -1,8 +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'
+    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()

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})}

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()
+                                ]
+                            ),
+                        )
+                    )

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

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"]

camomilla/{fields.py → 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]

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):

camomilla/managers/__init__.py

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

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

camomilla/model_api.py

@@ -0,0 +1,86 @@
+from rest_framework import routers
+
+from django.urls import path, include
+from camomilla.views.base import BaseModelViewset
+from camomilla.serializers.base import BaseModelSerializer
+
+router = routers.DefaultRouter()
+urlpatterns = []
+
+
+def register(
+    base_serializer=BaseModelSerializer,
+    base_viewset=BaseModelViewset,
+    serializer_meta={},
+    viewset_attrs={},
+    filters=None,
+):
+    """
+    Register a model to the API.
+    :param base_serializer: The base serializer to use for the model.
+    :param base_viewset: The base viewset to use for the model.
+    :param serializer_meta: The meta class to use for the serializer.
+    :param viewset_attrs: The attributes to add to the viewset.
+    :param filters: The filters to apply to the queryset.
+    :return: The model.
+    """
+
+    def inner(model):
+        global urlpatterns
+        base_meta = {
+            "model": model,
+            "fields": "__all__",
+        }
+        if "exclude" in serializer_meta:
+            base_meta.pop("fields")
+        serializer = type(
+            f"{model.__name__}Serializer",
+            (base_serializer,),
+            {
+                "Meta": type(
+                    "Meta",
+                    (),
+                    {
+                        **base_meta,
+                        **serializer_meta,
+                    },
+                )
+            },
+        )
+
+        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,),
+            {
+                "queryset": model.objects.all(),
+                "model": model,
+                "get_queryset": get_queryset,
+                "serializer_class": serializer,
+                **viewset_attrs,
+            },
+        )
+
+        model_path = "".join(
+            [
+                (
+                    "-" + character.lower()
+                    if character.isupper() and index > 0
+                    else character
+                )
+                for index, character in enumerate(model.__name__)
+            ]
+        ).lstrip("-")
+
+        router.register(
+            f"{model_path.replace(' ', '_').lower().lower()}",
+            viewset,
+            f"{model.__name__.lower()}_api",
+        )
+        urlpatterns = [path("", include(router.urls))]
+        return model
+
+    return inner

camomilla/models/__init__.py

@@ -1,6 +1,5 @@
-from .article import *
-from .category import *
-from .content import *
-from .media import *
-from .page import *
-from .tag import *
+from .article import *  # NOQA
+from .content import *  # NOQA
+from .media import *  # NOQA
+from .page import *  # NOQA
+from .menu import *  # NOQA

camomilla/models/article.py

@@ -1,62 +1,44 @@
-from django.conf import settings
+from django.conf import settings as dj_settings
 from django.db import models
 
-from django.utils.translation import gettext_lazy as _
+from camomilla.models.page import AbstractPage
+from camomilla import settings
 
-from hvad.models import TranslatedFields
 
-from .mixins import SeoMixin, MetaMixin
-
-
-CONTENT_STATUS = (
-    ("PUB", _("Published")),
-    ("DRF", _("Draft")),
-    ("TRS", _("Trash")),
-    ("PLA", _("Planned")),
-)
-
-
-class BaseArticle(SeoMixin, MetaMixin):
-
-    seo_attr = "permalink"
-
-    identifier = models.CharField(max_length=200, unique=True)
-    translations = TranslatedFields(
-        content=models.TextField(default=""),
-        permalink=models.SlugField(max_length=200, blank=False),
-    )
+class AbstractArticle(AbstractPage):
+    content = models.TextField(default="")
     author = models.ForeignKey(
-        settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
-    )
-    status = models.CharField(
-        max_length=3,
-        choices=CONTENT_STATUS,
-        default="DRF",
+        dj_settings.AUTH_USER_MODEL, blank=True, null=True, on_delete=models.SET_NULL
     )
     highlight_image = models.ForeignKey(
-        "camomilla.Media", blank=True, null=True, on_delete=models.SET_NULL
+        "camomilla.Media",
+        blank=True,
+        null=True,
+        on_delete=models.SET_NULL,
+        related_name="%(app_label)s_%(class)s_highlight_images",
     )
-    date = models.DateTimeField(auto_now=True)
-    pubblication_date = models.DateTimeField(null=True, blank=True)
-    tags = models.ManyToManyField("camomilla.Tag", blank=True)
-    categories = models.ManyToManyField("camomilla.Category", blank=True)
-    ordering = models.PositiveIntegerField(default=0, blank=False, null=False)
+    tags = models.ManyToManyField("Tag", blank=True)
 
     class Meta:
         abstract = True
-        unique_together = [("permalink", "language_code")]
         ordering = ["ordering"]
 
-    def save(self, *args, **kwargs):
-        import uuid
 
-        if not self.identifier:
-            self.identifier = "{0}".format(str(uuid.uuid4()))
-        super(BaseArticle, self).save(*args, **kwargs)
+class Article(AbstractArticle):
+    class PageMeta:
+        default_template = settings.ARTICLE_DEFAULT_TEMPLATE
+        inject_context_func = settings.ARTICLE_INJECT_CONTEXT_FUNC
+
+
+class AbstractTag(models.Model):
+    name = models.CharField(max_length=200, unique=True)
+
+    class Meta:
+        abstract = True
 
     def __str__(self):
-        return self.title
+        return "(%s) %s" % (self.__class__.__name__, self.name)
 
 
-class Article(BaseArticle):
-    translations = TranslatedFields()
+class Tag(AbstractTag):
+    pass

camomilla/models/content.py

@@ -1,20 +1,11 @@
 from django.db import models
-
 from django.urls import reverse
-
-from hvad.models import TranslatableModel, TranslatedFields
-
 from djsuperadmin.mixins import DjSuperAdminMixin
 
 
-class BaseContent(DjSuperAdminMixin, TranslatableModel):
-    identifier = models.CharField(max_length=200)
-    translations = TranslatedFields(
-        title=models.CharField(max_length=200),
-        subtitle=models.CharField(max_length=200, blank=True, null=True, default=""),
-        permalink=models.CharField(max_length=200, blank=False, null=True),
-        content=models.TextField(default=""),
-    )
+class AbstractContent(DjSuperAdminMixin, models.Model):
+    identifier = models.TextField()
+    content = models.TextField(default="")
     page = models.ForeignKey(
         "camomilla.Page",
         blank=False,
@@ -33,11 +24,13 @@ class BaseContent(DjSuperAdminMixin, TranslatableModel):
 
     class Meta:
         abstract = True
-        unique_together = [("page", "identifier")]
+        unique_together = ["identifier", "page"]
 
     def __str__(self):
+        if len(self.identifier) > 40:
+            return "%s..." % self.identifier[:40]
         return self.identifier
 
 
-class Content(BaseContent):
-    translations = TranslatedFields()
+class Content(AbstractContent):
+    pass