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

camomilla/models/media.py

@@ -1,39 +1,30 @@
 import json
 import os
-import magic
 from io import BytesIO
 
-from django.conf import settings
+import magic
 from django.core.exceptions import ValidationError
 from django.core.files.base import ContentFile
-from django.core.files.storage import default_storage as storage
 from django.db import models
 from django.db.models.fields.related import ForeignObjectRel
-from ..fields import JSONField
 from django.db.models.signals import post_save, pre_delete
 from django.dispatch import receiver
 from django.utils.safestring import mark_safe
+from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
-from hvad.models import TranslatableModel, TranslatedFields
 from PIL import Image
 
+from camomilla.fields import JSONField
+from camomilla.settings import THUMBNAIL_FOLDER, THUMBNAIL_HEIGHT, THUMBNAIL_WIDTH
+from camomilla.storages.optimize import OptimizedStorage
 
-class BaseMediaFolder(TranslatableModel):
-    translations = TranslatedFields(
-        description=models.CharField(max_length=200, blank=True, null=True),
-        title=models.CharField(max_length=200, blank=True, null=True),
-    )
-    slug = models.SlugField()
+
+class AbstractMediaFolder(models.Model):
+    title = models.CharField(max_length=200)
+    slug = models.SlugField(editable=False, max_length=200, blank=True, null=True)
     creation_date = models.DateTimeField(auto_now_add=True)
     last_modified = models.DateTimeField(auto_now=True)
-    icon = models.ForeignKey(
-        "camomilla.Media",
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        verbose_name=_("Image cover"),
-    )
-    path = models.TextField(blank=True, null=True)
+    path = models.TextField(blank=True, null=True, editable=False)
     updir = models.ForeignKey(
         "self",
         on_delete=models.CASCADE,
@@ -50,46 +41,42 @@ class BaseMediaFolder(TranslatableModel):
             folder.save()
 
     def save(self, *args, **kwargs):
+        self.slug = slugify(self.title)
         if self.updir:
             if self.updir.id == self.id:
                 raise ValidationError({"updir": "Unvalid parent"})
             self.path = "{0}/{1}".format(self.updir.path, self.slug)
-
         else:
             self.path = "/{0}".format(self.slug)
 
-        super(BaseMediaFolder, self).save(*args, **kwargs)
+        super().save(*args, **kwargs)
         self.update_childs()
 
     def __str__(self):
-        to_string = self.slug
-        if self.title:
-            to_string += " - " + self.title
-        return to_string
+        return "[%s] %s" % (self.__class__.__name__, self.title)
 
 
-class MediaFolder(BaseMediaFolder):
-    translations = TranslatedFields()
+class MediaFolder(AbstractMediaFolder):
+    pass
 
 
-class Media(TranslatableModel):
-    translations = TranslatedFields(
-        alt_text=models.CharField(max_length=200, blank=True, null=True),
-        title=models.CharField(max_length=200, blank=True, null=True),
-        description=models.TextField(blank=True, null=True),
-    )
-    file = models.FileField()
+class Media(models.Model):
+    # Seo Attributes
+    alt_text = models.CharField(max_length=200, blank=True, null=True)
+    title = models.CharField(max_length=200, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    file = models.FileField(storage=OptimizedStorage())
     thumbnail = models.ImageField(
-        upload_to=getattr(settings, "THUMB_FOLDER", "thumbnails"),
+        upload_to=THUMBNAIL_FOLDER,
         max_length=500,
         null=True,
         blank=True,
     )
     created = models.DateTimeField(auto_now=True)
-    name = models.CharField(max_length=200, blank=True, null=True)
-    size = models.IntegerField(default=0, blank=True, null=True)
-    mime_type = models.CharField(max_length=128, blank=True, null=True)
-    image_props = JSONField(default=dict, blank=True)
+    size = models.IntegerField(default=0, blank=True, null=True, editable=False)
+    mime_type = models.CharField(max_length=128, blank=True, null=True, editable=False)
+    image_props = JSONField(default=dict, blank=True, editable=False)
     folder = models.ForeignKey(
         MediaFolder,
         null=True,
@@ -121,6 +108,7 @@ class Media(TranslatableModel):
         ordering = ["-pk"]
 
     def regenerate_thumbnail(self):
+        self._remove_thumbnail()
         if self.file:
             self._make_thumbnail()
 
@@ -140,53 +128,42 @@ class Media(TranslatableModel):
         }
         return json.dumps(json_r)
 
-    def _make_thumbnail(self):
-        try:
-            fh = storage.open(self.file.name, "rb")
-            self.mime_type = magic.from_buffer(fh.read(2048), mime=True)
-        except FileNotFoundError as ex:
-            print(ex)
-            self.image_props = {}
-            self.mime_type = ""
-            return False
+    def _update_file_info(self, img_bytes=None):
         try:
-            orig_image = Image.open(fh)
-            image = orig_image.copy()
-            self.image_props = {
-                "width": orig_image.width,
-                "height": orig_image.height,
-                "format": orig_image.format,
-                "mode": orig_image.mode,
-            }
+            if not img_bytes:
+                img_bytes = self.file.storage.open(self.file.name, "rb")
+            self.mime_type = magic.from_buffer(img_bytes.read(2048), mime=True)
+            with Image.open(img_bytes) as image:
+                self.image_props = {
+                    "width": image.width,
+                    "height": image.height,
+                    "format": image.format,
+                    "mode": image.mode,
+                }
         except Exception as ex:
             print(ex)
             return False
 
+    def _make_thumbnail(self, img_bytes=None):
         try:
-            image.thumbnail(
-                (
-                    getattr(settings, "CAMOMILLA_THUMBNAIL_WIDTH", 50),
-                    getattr(settings, "CAMOMILLA_THUMBNAIL_HEIGHT", 50),
-                ),
-                Image.ANTIALIAS,
-            )
-            fh.close()
-
-            # Path to save to, name, and extension
-            thumb_name, thumb_extension = os.path.splitext(self.file.name)
-            thumb_extension = thumb_extension.lower()
-
-            thumb_filename = thumb_name + "_thumb" + thumb_extension
-
-            temp_thumb = BytesIO()
-            image.save(temp_thumb, "PNG", optimize=True)
-            temp_thumb.seek(0)
-
-            # Load a ContentFile into the thumbnail field so it gets saved
-            self.thumbnail.save(
-                thumb_filename, ContentFile(temp_thumb.read()), save=False
-            )
-            temp_thumb.close()
+            if not img_bytes:
+                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.LANCZOS)
+
+                # Path to save to, name, and extension
+                thumb_name, thumb_extension = os.path.splitext(self.file.name)
+                thumb_extension = thumb_extension.lower()
+                thumb_filename = thumb_name + "_thumb" + thumb_extension
+                temp_thumb = BytesIO()
+                image.save(temp_thumb, "PNG", optimize=True)
+                temp_thumb.seek(0)
+                # Load a ContentFile into the thumbnail field so it gets saved
+                self.thumbnail.save(
+                    thumb_filename, ContentFile(temp_thumb.read()), save=False
+                )
+                temp_thumb.close()
         except Exception:
             return False
 
@@ -194,34 +171,30 @@ class Media(TranslatableModel):
 
     def _remove_file(self):
         if self.file:
-            file_to_remove = os.path.join(settings.MEDIA_ROOT, self.file.name)
-            if os.path.isfile(file_to_remove):
-                os.remove(file_to_remove)
+            self.file.storage.delete(self.file.name)
 
     def _remove_thumbnail(self):
         if self.thumbnail:
-            file_to_remove = os.path.join(settings.MEDIA_ROOT, self.thumbnail.name)
-            if os.path.isfile(file_to_remove):
-                os.remove(file_to_remove)
+            self.thumbnail.storage.delete(self.thumbnail.name)
 
     def _get_file_size(self):
-        if self.file:
-            file_to_calc = os.path.join(settings.MEDIA_ROOT, self.file.name)
-            if os.path.isfile(file_to_calc):
-                return self.file.size
-            else:
-                return 0
+        try:
+            return self.file.storage.size(self.file.name)
+        except Exception:
+            return 0
 
     def __str__(self):
-        if self.name:
-            return self.name
+        if self.title:
+            return self.title
         return self.file.name
 
 
 @receiver(post_save, sender=Media, dispatch_uid="make thumbnails")
-def update_media(sender, instance, **kwargs):
+def update_media(sender, instance: Media, **kwargs):
     instance._remove_thumbnail()
-    instance._make_thumbnail()
+    image_bytes = instance.file.storage.open(instance.file.name, "rb")
+    instance._update_file_info(image_bytes)
+    instance._make_thumbnail(image_bytes)
     Media.objects.filter(pk=instance.pk).update(
         size=instance._get_file_size(),
         thumbnail=instance.thumbnail,
@@ -231,6 +204,6 @@ def update_media(sender, instance, **kwargs):
 
 
 @receiver(pre_delete, sender=Media, dispatch_uid="make thumbnails")
-def delete_media_files(sender, instance, **kwargs):
+def delete_media_files(sender, instance: Media, **kwargs):
     instance._remove_thumbnail()
     instance._remove_file()

camomilla/models/menu.py

@@ -0,0 +1,106 @@
+from enum import Enum
+from uuid import uuid4
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django.template.loader import render_to_string
+from django.template import RequestContext
+from django.utils.safestring import mark_safe
+from pydantic import (
+    Field,
+    SerializationInfo,
+    computed_field,
+    model_serializer,
+)
+from structured.pydantic.models import BaseModel
+from structured.fields import StructuredJSONField
+from camomilla.models.page import UrlNode, AbstractPage
+from typing import Optional, Union, Callable, List
+from django.db.models.base import Model as DjangoModel
+
+
+class LinkTypes(str, Enum):
+    relational = "RE"
+    static = "ST"
+
+
+class MenuNodeLink(BaseModel):
+    link_type: LinkTypes = LinkTypes.static
+    static: str = None
+    content_type: ContentType = None
+    page: AbstractPage = None
+    url_node: UrlNode = None
+
+    @model_serializer(mode="wrap", when_used="json")
+    def update_relational(self, handler: Callable, info: SerializationInfo):
+        if self.link_type == LinkTypes.relational:
+            if self.content_type and self.page:
+                if isinstance(self.page, DjangoModel) and not self.page._meta.abstract:
+                    self.content_type = ContentType.objects.get_for_model(
+                        self.page.__class__
+                    )
+                ctype_id = getattr(self.content_type, "pk", self.content_type)
+                page_id = getattr(self.page, "pk", self.page)
+                c_type = ContentType.objects.filter(pk=ctype_id).first()
+                model = c_type and c_type.model_class()
+                page = model and model.objects.filter(pk=page_id).first()
+                self.url_node = page and page.url_node
+            elif self.url_node:
+                url_node_id = getattr(self.url_node, "pk", self.url_node)
+                self.page = UrlNode.objects.filter(pk=url_node_id).first().page
+                self.content_type = ContentType.objects.get_for_model(
+                    self.page.__class__
+                )
+        return handler(self)
+
+    def get_url(self, request=None):
+        if self.link_type == LinkTypes.relational:
+            return isinstance(self.url_node, UrlNode) and self.url_node.routerlink
+        elif self.link_type == LinkTypes.static:
+            return self.static
+
+    @computed_field
+    @property
+    def url(self) -> Optional[str]:
+        return self.get_url()
+
+
+class MenuNode(BaseModel):
+    id: str = Field(default_factory=uuid4)
+    meta: dict = {}
+    nodes: List["MenuNode"] = []
+    title: str = ""
+    link: MenuNodeLink
+
+
+class Menu(models.Model):
+    key = models.CharField(max_length=200, unique=True, editable=False)
+    available_classes = models.JSONField(default=dict, editable=False)
+    enabled = models.BooleanField(default=True)
+    nodes = StructuredJSONField(default=list, schema=MenuNode)
+
+    class Meta:
+        verbose_name = _("menu")
+        verbose_name_plural = _("menus")
+
+    def render(
+        self,
+        template_path: str,
+        request=None,
+        context: Union[dict, RequestContext] = {},
+    ):
+        if isinstance(context, RequestContext):
+            context = context.flatten()
+        is_preview = (
+            False if request is None else 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):
+        def __missing__(self, key):
+            dict.__setitem__(self, key, Menu.objects.get_or_create(key=key)[0])
+            return self[key]
+
+    def __str__(self) -> str:
+        return self.key

camomilla/models/mixins/__init__.py

@@ -1,66 +1,28 @@
 from django.db import models
-from ...fields import JSONField
-from hvad.models import TranslatableModel, TranslatedFields
 
-from django.utils.translation import gettext_lazy as _
-from django.utils.text import slugify
 
-from ...utils import get_seo_model
-
-from djlotrek.utils import alternate_seo_url_with_object
-
-
-class SeoMixin(TranslatableModel):
-
-    seo_attr = "identifier"
-
-    translations = TranslatedFields(
-        title=models.CharField(max_length=200),
-        description=models.TextField(blank=True, null=True, default=""),
-        permalink=models.CharField(max_length=200, blank=True),
-        og_description=models.TextField(blank=True, null=True, default=""),
-        og_title=models.CharField(max_length=200, blank=True, null=True, default=""),
-        og_type=models.CharField(max_length=200, blank=True, null=True, default=""),
-        og_url=models.CharField(max_length=200, blank=True, null=True, default=""),
-        canonical=models.CharField(max_length=200, blank=True, null=True, default=""),
-    )
+class SeoMixin(models.Model):
+    title = models.CharField(max_length=200, null=True, blank=True)
+    description = models.TextField(null=True, blank=True)
+    og_description = models.TextField(blank=True, null=True)
+    og_title = models.CharField(max_length=200, blank=True, null=True)
+    og_type = models.CharField(max_length=200, blank=True, null=True)
+    og_url = models.CharField(max_length=200, blank=True, null=True)
+    canonical = models.CharField(max_length=200, blank=True, null=True)
     og_image = models.ForeignKey(
         "camomilla.Media",
         blank=True,
         null=True,
         on_delete=models.SET_NULL,
-        related_name="%(app_label)s_%(class)s_related",
+        related_name="%(app_label)s_%(class)s_og_images",
     )
 
-    @classmethod
-    def get(model, request, **kwargs):
-        return get_seo_model(request, model, **kwargs)
-
-    def alternate_urls(self, request):
-        return alternate_seo_url_with_object(
-            request, self.__class__, permalink=self.permalink
-        )
-
     class Meta:
         abstract = True
 
 
-class SlugMixin(object):
-
-    slug_attr = "title"
-
-    def get_slug(self):
-        return self.slug
-
-    get_slug.short_description = _("Slug")
-
-    def save(self, *args, **kwargs):
-        self.slug = slugify(getattr(self, self.slug_attr))
-        super(SlugMixin, self).save(*args, **kwargs)
-
-
 class MetaMixin(models.Model):
-    meta = JSONField(default=dict)
+    meta = models.JSONField(default=dict, null=False, blank=True)
 
     def get_meta(self, key, default=None):
         return self.meta.get(key, default)