django-camomilla-cms 6.0.0b2__py2.py3-none-any.whl → 6.0.0b4__py2.py3-none-any.whl

camomilla/serializers/fields/json.py

@@ -1,15 +1,6 @@
 from rest_framework import serializers
 from rest_framework.utils import model_meta
 
-from camomilla.serializers.utils import build_standard_model_serializer
-from camomilla.structured.fields import (
-    EmbeddedField,
-    ForeignKey,
-    ForeignKeyList,
-    ListField,
-)
-from camomilla.structured.models import Model
-
 
 class StructuredJSONField(serializers.JSONField):
     def __init__(self, **kwargs):
@@ -21,72 +12,13 @@ class StructuredJSONField(serializers.JSONField):
             info = model_meta.get_field_info(parent.Meta.model)
             field = info.fields[field_name]
             self.schema = field.schema
+            self.many = field.many
+            self.json_schema = field.schema.json_schema()
         super().bind(field_name, parent)
 
-    def to_internal_value(self, data):
-        if isinstance(data, dict):
-            data = to_internal_model_value(self.schema, data)
-        elif isinstance(data, list):
-            data = [to_internal_model_value(self.schema, v) for v in data]
-        return super().to_internal_value(data)
-
     def to_representation(self, instance):
-        return super().to_representation(expanded_rapresentation(instance))
-
-
-def expanded_model_rapresentation(schema: Model):
-    stack = {}
-    for _, name, field in schema.iterate_with_name():
-        value = field.__get__(schema)
-        if value is None:
-            continue
-        elif isinstance(field, ForeignKey):
-            serializer = build_standard_model_serializer(field.model, depth=1)
-            data = serializer(instance=value).data
-        elif isinstance(field, ForeignKeyList):
-            serializer = build_standard_model_serializer(field.inner_model, depth=1)
-            data = serializer(instance=value, many=True).data
-        elif isinstance(field, EmbeddedField):
-            data = expanded_model_rapresentation(value)
-        elif isinstance(field, ListField):
-            data = []
-            for v in value:
-                if isinstance(v, Model):
-                    v = expanded_model_rapresentation(v)
-                data.append(v)
-        else:
-            data = field.to_struct(value)
-        stack[name] = data
-    return stack
-
-
-def expanded_rapresentation(value):
-    if isinstance(value, dict):
-        value = {k: expanded_rapresentation(v) for k, v in value.items()}
-    elif isinstance(value, list):
-        value = [expanded_rapresentation(v) for v in value]
-    elif isinstance(value, Model):
-        value = expanded_model_rapresentation(value)
-    return value
-
-
-def to_internal_model_value(schema: Model, data):
-    stack = {}
-    for _, name, field in schema.iterate_with_name():
-        value = data.get(name, None)
-        if value is None:
-            continue
-        if isinstance(field, ForeignKey) and isinstance(value, dict):
-            value = value.get(field.model._meta.pk.attname, None)
-        elif isinstance(field, ForeignKeyList) and isinstance(value, list):
-            attname = field.model._meta.pk.attname
-            value = [v.get(attname, None) for v in value]
-        elif isinstance(field, EmbeddedField):
-            value = to_internal_model_value(field._get_embed_type(), value)
-        elif isinstance(field, ListField):
-            main_type = field._get_main_type()
-            value = [to_internal_model_value(main_type, v) for v in value]
-        else:
-            value = field.to_struct(value)
-        stack[name] = value
-    return stack
+        if isinstance(instance, list) and self.many:
+            return super().to_representation(
+                self.schema.dump_python(instance, exclude_unset=True)
+            )
+        return super().to_representation(instance.model_dump(exclude_unset=True))

camomilla/serializers/mixins/__init__.py

@@ -20,6 +20,9 @@ if django.VERSION >= (4, 0):
 else:
     from django.contrib.postgres.fields import JSONField as DjangoJSONField
 
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from camomilla.models.page import AbstractPage
 
 # TODO: decide what to do with LangInfoMixin mixin!
 class LangInfoMixin(metaclass=serializers.SerializerMetaclass):
@@ -121,8 +124,17 @@ class NestMixin:
         return field_class, field_kwargs
 
 
-
 class AbstractPageMixin(serializers.ModelSerializer):
+    breadcrumbs = serializers.SerializerMethodField()
+    routerlink = serializers.CharField(read_only=True)
+    template = serializers.SerializerMethodField()
+    
+    def get_template(self, instance: 'AbstractPage'):
+        return instance.get_template_path()
+    
+    def get_breadcrumbs(self, instance: 'AbstractPage'):
+        return instance.breadcrumbs
+    
     LANG_PERMALINK_FIELDS = [
         build_localized_fieldname("permalink", lang)
         for lang in AVAILABLE_LANGUAGES
@@ -134,6 +146,9 @@ class AbstractPageMixin(serializers.ModelSerializer):
         return super().translation_fields + ["permalink"]
 
     def get_default_field_names(self, *args):
+        from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
+        if RemoveTranslationsMixin in self.__class__.__bases__:  # noqa: E501
+            return super().get_default_field_names(*args)
         return (
             [f for f in super().get_default_field_names(*args) if f != "url_node"]
             + self.LANG_PERMALINK_FIELDS
@@ -150,4 +165,3 @@ class AbstractPageMixin(serializers.ModelSerializer):
 
     def get_validators(self):
         return super().get_validators() + [UniquePermalinkValidator()]
- 

camomilla/serializers/page.py

@@ -1,7 +1,13 @@
+from camomilla.models.page import UrlNode
 from camomilla.serializers.mixins import AbstractPageMixin
 from camomilla.models import Content, Page
 from camomilla.serializers.base import BaseModelSerializer
+from rest_framework import serializers
 
+from camomilla.serializers.utils import (
+    build_standard_model_serializer,
+    get_standard_bases,
+)
 
 
 class ContentSerializer(BaseModelSerializer):
@@ -14,3 +20,44 @@ class PageSerializer(AbstractPageMixin, BaseModelSerializer):
     class Meta:
         model = Page
         fields = "__all__"
+
+
+class BasicUrlNodeSerializer(BaseModelSerializer):
+    is_public = serializers.SerializerMethodField()
+    status = serializers.SerializerMethodField()
+    indexable = serializers.SerializerMethodField()
+
+    class Meta:
+        model = UrlNode
+        fields = ("id", "permalink", "status", "indexable", "is_public")
+
+    def get_is_public(self, instance: UrlNode):
+        return instance.page.is_public
+
+    def get_status(self, instance: UrlNode):
+        return instance.page.status
+
+    def get_indexable(self, instance: UrlNode):
+        return instance.page.indexable
+
+
+class UrlNodeSerializer(BasicUrlNodeSerializer):
+    alternates = serializers.SerializerMethodField()
+
+    def get_alternates(self, instance: UrlNode):
+        return instance.page.alternate_urls()
+
+    def to_representation(self, instance: UrlNode):
+        model_serializer = build_standard_model_serializer(
+            instance.page.__class__,
+            depth=10,
+            bases=(AbstractPageMixin,) + get_standard_bases(),
+        )
+        return {
+            **super().to_representation(instance),
+            **model_serializer(instance.page, context=self.context).data,
+        }
+
+    class Meta:
+        model = UrlNode
+        fields = "__all__"

camomilla/serializers/user.py

@@ -40,8 +40,8 @@ class UserProfileSerializer(BaseModelSerializer):
     def get_all_permissions(self, instance):
         return PermissionSerializer(
             Permission.objects.filter(
-                Q(group__pk__in=instance.groups.values_list("pk", flat=True)) |
-                Q(pk__in=instance.user_permissions.values_list("pk", flat=True))
+                Q(group__pk__in=instance.groups.values_list("pk", flat=True))
+                | Q(pk__in=instance.user_permissions.values_list("pk", flat=True))
             ),
             context=self.context,
             many=True,
@@ -68,7 +68,6 @@ class UserProfileSerializer(BaseModelSerializer):
 
 
 class UserSerializer(BaseModelSerializer):
-
     id = serializers.IntegerField(read_only=True)
     password = serializers.CharField(
         write_only=True, required=False, allow_null=True, allow_blank=True

camomilla/serializers/utils.py

@@ -1,22 +1,27 @@
+def get_standard_bases() -> tuple:
+    from rest_framework.serializers import ModelSerializer
+    from camomilla.serializers.fields import FieldsOverrideMixin
+    from camomilla.contrib.rest_framework.serializer import RemoveTranslationsMixin
+    from camomilla.serializers.mixins import (
+        JSONFieldPatchMixin,
+        NestMixin,
+        OrderingMixin,
+        SetupEagerLoadingMixin,
+    )
+
+    return (
+        NestMixin,
+        FieldsOverrideMixin,
+        JSONFieldPatchMixin,
+        OrderingMixin,
+        RemoveTranslationsMixin,
+        SetupEagerLoadingMixin,
+        ModelSerializer,
+    )
+
 def build_standard_model_serializer(model, depth, bases=None):
     if bases is None:
-        from rest_framework.serializers import ModelSerializer
-        from camomilla.serializers.fields import FieldsOverrideMixin
-        from camomilla.serializers.mixins import (
-            JSONFieldPatchMixin,
-            NestMixin,
-            OrderingMixin,
-            SetupEagerLoadingMixin,
-        )
-
-        bases = (
-            NestMixin,
-            FieldsOverrideMixin,
-            JSONFieldPatchMixin,
-            OrderingMixin,
-            SetupEagerLoadingMixin,
-            ModelSerializer,
-        )
+        bases = get_standard_bases()
     return type(
         f"{model.__name__}StandardSerializer",
         bases,

camomilla/settings.py

@@ -67,6 +67,20 @@ ENABLE_MEDIA_OPTIMIZATION = pointed_getter(
 
 API_NESTING_DEPTH = pointed_getter(django_settings, "CAMOMILLA.API.NESTING_DEPTH", 10)
 
+AUTO_CREATE_HOMEPAGE = pointed_getter(
+    django_settings, "CAMOMILLA.RENDER.AUTO_CREATE_HOMEPAGE", True
+)
+
+TEMPLATE_CONTEXT_FILES = pointed_getter(
+    django_settings, "CAMOMILLA.RENDER.TEMPLATE_CONTEXT_FILES", []
+)
+
+STRUCTURED_FIELD_CACHE_ENABLED = pointed_getter(
+    django_settings, "CAMOMILLA.STRUCTURED_FIELD.CACHE_ENABLED", True
+)
+
+DEBUG = pointed_getter(django_settings, "CAMOMILLA.DEBUG", django_settings.DEBUG)
+
 # camomilla settings example
 # CAMOMILLA = {
 #     "PROJECT_TITLE": "",
@@ -78,8 +92,14 @@ API_NESTING_DEPTH = pointed_getter(django_settings, "CAMOMILLA.API.NESTING_DEPTH
 #         "THUMBNAIL": {"FOLDER": "", "WIDTH": 50, "HEIGHT": 50}
 #     },
 #     "RENDER": {
+#         "TEMPLATE_CONTEXT_FILES": [],
+#         "AUTO_CREATE_HOMEPAGE": True,
 #         "ARTICLE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None },
 #         "PAGE": {"DEFAULT_TEMPLATE": "", "INJECT_CONTEXT": None }
 #     },
-#     "API": {"NESTING_DEPTH": 10 }
+#     "STRUCTURED_FIELD": {
+#         "CACHE_ENABLED": True
+#     }
+#     "API": {"NESTING_DEPTH": 10 },
+#     "DEBUG": False
 # }

camomilla/storages/optimize.py

@@ -47,6 +47,6 @@ class OptimizedStorage(get_storage_class()):
             tmp.close()
             content.close()
             return optimized_content, True
-        except:
+        except Exception:
             traceback.print_exc()
             return content, False

camomilla/structured/__init__.py

@@ -1,40 +1,47 @@
-from collections import defaultdict
+import json
 from typing import Any
 
 from django.db.models import JSONField
 from django.db.models.query_utils import DeferredAttribute
+from django_jsonform.models.fields import JSONFormField
+from pydantic import (
+    TypeAdapter,
+    ValidationInfo,
+    ValidatorFunctionWrapHandler,
+    WrapValidator,
+)
 
 from .fields import *
 from .models import *
-from .models import _Cache, build_model_cache
+
+
+class StructuredJSONFormField(JSONFormField):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.encoder = kwargs.get("encoder", None)
+        self.decoder = kwargs.get("decoder", None)
+
+    def prepare_value(self, value):
+        if isinstance(value, list):
+            return json.dumps([v.model_dump() for v in value])
+        return value.model_dump_json()
 
 
 class StructuredDescriptior(DeferredAttribute):
+    field: "StructuredJSONField"
+
     def __set__(self, instance, value):
-        if isinstance(value, dict):
-            self.field.prefetch_related(value)
-            value = self.field.populate_schema(value)
-        elif isinstance(value, list):
-            self.field.prefetch_related(value)
-            _stack = []
-            for v in value:
-                if isinstance(v, dict):
-                    v = self.field.populate_schema(v)
-                elif not isinstance(v, self.field.schema):
-                    raise TypeError(
-                        f"{type(v)} is not a valid type for the given schema ({self.field.schema})."
-                    )
-                v.validate()
-                _stack.append(v)
-            value = _stack
-        elif isinstance(value, self.field.schema):
-            value.validate()
-        else:
-            raise TypeError(
-                f"{type(value)} is not a valid type for the given schema ({self.field.schema})."
-            )
+        # TODO: check if it's better to validate here or in __get__ function (performance reasons)
+        # if not self.field.check_type(value):
+        #     value = self.field.schema.validate_python(value)
         instance.__dict__[self.field.attname] = value
 
+    def __get__(self, instance, cls=None):
+        value = super().__get__(instance, cls)
+        if not self.field.check_type(value):
+            return self.field.schema.validate_python(value)
+        return value
+
 
 class StructuredJSONField(JSONField):
     # TODO: share cache in querysets of models having this same field
@@ -42,64 +49,72 @@ class StructuredJSONField(JSONField):
 
     descriptor_class = StructuredDescriptior
 
-    def __init__(self, schema, *args: Any, **kwargs: Any) -> None:
-        self.schema = schema
-        self._cache = _Cache(self)
-        return super().__init__(*args, **kwargs)
+    @property
+    def list_data_validator(self):
+        def list_data_validator(
+            value: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo
+        ) -> Any:
+            from camomilla.structured.cache import CacheBuilder
 
-    def populate_schema(self, struct):
-        schema_intance = self.schema()
-        relations = schema_intance.prepopulate(**struct)
-        schema_intance.bind(self)
-        schema_intance.populate(**relations)
-        return schema_intance
+            cache = CacheBuilder.from_model(self.orig_schema)
+            if info.mode == "json" and isinstance(value, str):
+                return self.schema.validate_python(
+                    cache.inject_cache(json.loads(value))
+                )
+            return handler(cache.inject_cache(value))
 
-    def get_prep_value(self, value):
-        if not value:
-            return super().get_prep_value(value)
-        if isinstance(value, list):
-            value = [
-                (v if isinstance(v, self.schema) else self.populate_schema(v))
-                for v in value
-            ]
-            value = [self.schema.to_db_transform(v.to_struct()) for v in value]
-        elif isinstance(value, dict):
-            value = self.schema.to_db_transform(self.populate_schema(value).to_struct())
-        elif isinstance(value, self.schema):
-            value = self.schema.to_db_transform(value.to_struct())
-        else:
-            raise TypeError(f"{type(value)} is not a valid type for the given schema.")
-        return super().get_prep_value(value)
-
-    def from_db_value(self, value, expression, connection):
-        return self.schema.from_db_transform(
-            super().from_db_value(value, expression, connection)
+        return list_data_validator
+
+    def __init__(self, schema: type[BaseModel], *args: Any, **kwargs: Any) -> None:
+        self.orig_schema = schema
+        self.schema = schema
+        default = kwargs.get("default", dict)
+        self.file_handler = kwargs.pop("file_handler", "")
+        self.many = kwargs.pop(
+            "many", isinstance(default() if callable(default) else default, list)
         )
+        if self.many:
+            self.schema = TypeAdapter(
+                Annotated[
+                    list[self.schema],
+                    Field(default_factory=list),
+                    WrapValidator(self.list_data_validator),
+                ]
+            )
+        return super().__init__(*args, **kwargs)
 
-    def get_prefetched_data(self):
-        return self._cache.get_prefetched_data()
-
-    def get_all_relateds(self, struct):
-        if isinstance(struct, list):
-            relateds = defaultdict(set)
-            for inner_struct in struct:
-                if isinstance(inner_struct, dict):
-                    child_relateds = self.schema.get_all_relateds(inner_struct)
-                    for model, pks in child_relateds.items():
-                        relateds[model].update(pks)
-            return relateds
-        return self.schema.get_all_relateds(struct)
-
-    def prefetch_related(self, struct):
-        relateds = self.get_all_relateds(struct)
-        for model, pks in relateds.items():
-            self._cache.prefetched_data[model] = (
-                {obj.pk: obj for obj in build_model_cache(model, pks)}
-                if len(pks) > 0
-                else {}
+    def check_type(self, value: Any):
+        if self.many:
+            return isinstance(value, list) and all(
+                isinstance(v, self.orig_schema) for v in value
             )
+        return isinstance(value, self.orig_schema)
+
+    def get_prep_value(
+        self, value: Union[list[type[BaseModel]], type[BaseModel]]
+    ) -> str:
+        if isinstance(value, list) and self.many:
+            return self.schema.dump_json(value, exclude_unset=True).decode()
+        return value.model_dump_json(exclude_unset=True)
+
+    def from_db_value(self, value: Any, expression: Any, connection: Any) -> Any:
+        data = super().from_db_value(value, expression, connection)
+        if isinstance(data, str):
+            return json.loads(data)
+        return data
 
     def deconstruct(self):
         name, path, args, kwargs = super().deconstruct()
         kwargs["schema"] = self.schema
         return name, path, args, kwargs
+
+    def formfield(self, **kwargs):
+        return super().formfield(
+            **{
+                "form_class": StructuredJSONFormField,
+                "schema": self.schema.json_schema(),
+                "model_name": self.model.__name__,
+                "file_handler": self.file_handler,
+                **kwargs,
+            }
+        )