dynamicforms 0.77.4__tar.gz → 0.77.8__tar.gz

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/PKG-INFO

@@ -1,12 +1,13 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: dynamicforms
-Version: 0.77.4
+Version: 0.77.8
 Summary: DynamicForms performs all the visualisation & data entry of your DRF Serializers & ViewSets and adds some candy of its own
 Project-URL: Homepage, https://github.com/velis74/DynamicForms
 Project-URL: Repository, https://github.com/velis74/DynamicForms
 Project-URL: Bug Tracker, https://github.com/velis74/DynamicForms/issues
 Author-email: Jure Erznožnik <jure@velis.si>
-License: MIT
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: Django
 Classifier: License :: OSI Approved :: BSD License

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/dynamicforms/__init__.py

@@ -1,5 +1,5 @@
 __title__ = "DynamicForms"
-__version__ = '0.77.4'
+__version__ = '0.77.8'
 __author__ = "Jure Erznožnik"
 __email__ = "jure.erznoznik@gmail.com"
 __license__ = "BSD 3-Clause"

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/dynamicforms/fields.py

@@ -35,7 +35,24 @@ assert DFField  # So that the linter does not complain
 
 
 class AutoGeneratedField(dict):
-    pass
+    def get_serializer_field(self, name, serializer, extra_params=None):
+        from rest_framework.utils import model_meta
+
+        if not hasattr(serializer, "_df_model"):
+            serializer._df_model = getattr(serializer.Meta, "model")
+        if not hasattr(serializer, "_df_info"):
+            serializer._df_info = model_meta.get_field_info(serializer._df_model)
+        if not hasattr(serializer, "_df_depth"):
+            serializer._df_depth = getattr(serializer.Meta, "depth", 0)
+
+        if extra_params is None:
+            extra_params = self
+        field_class, field_kwargs = serializer.build_field(
+            name, serializer._df_info, serializer._df_model, serializer._df_depth
+        )
+        field_kwargs.update(extra_params)
+
+        return field_class(**field_kwargs)
 
 
 class BooleanField(FieldRenderMixin, ActionMixin, FieldHelpTextMixin, ConditionalVisibilityMixin, fields.BooleanField):

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/dynamicforms/mixins/choice/allow_tags.py

@@ -13,7 +13,7 @@ class DenormalisedArray(list):
             for itm in ast.literal_eval(lst):
                 self.append(itm)
 
-        elif lst is not None and isinstance(lst, list):
+        elif lst is not None and isinstance(lst, (list, set)):
             for itm in lst:
                 self.append(itm)
 

dynamicforms-0.77.8/dynamicforms/mixins/file_field.py

@@ -0,0 +1,52 @@
+from typing import TYPE_CHECKING
+
+from django.utils.translation import gettext_lazy as _
+
+if TYPE_CHECKING:
+    from rest_framework.fields import FileField
+
+
+class FileFieldMixin(object):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        # noinspection PyUnresolvedReferences
+        self.style.setdefault("no_filter", True)
+
+    def to_representation(self: "FileField", value, row_data=None):
+        if value:
+            return getattr(value, "url", None)
+        return None
+
+    def to_internal_value(self: "FileField", data):
+        from django.core.files.base import ContentFile
+        from rest_framework.exceptions import ValidationError
+
+        from dynamicforms.preupload_files import get_cached_file
+
+        if isinstance(data, str):  # dobimo guid
+            cached_file = get_cached_file(data, self.context["request"].user.id or -1, True)
+            if cached_file:
+                # Naredimo django file iz cache podatkov
+                return ContentFile(cached_file.content, name=cached_file.name)
+
+            # Če datoteke ni v cache-u in imamo obstoječo vrednost na instanci, vrnemo obstoječo vrednost
+            if self.parent.instance and getattr(self.parent.instance, self.field_name, None):
+                return str(getattr(self.parent.instance, self.field_name))
+            raise ValidationError(_("File not found in cache"))
+
+        if not self.allow_empty_file and not data:
+            self.fail("empty")
+
+        return super().to_internal_value(data)
+
+    def validate_empty_values(self: "FileField", data):
+        """Override za boljše rokovanje z empty vrednostmi"""
+        if data is None:
+            if self.required:
+                self.fail("required")
+            return True, None
+
+        if data == "" and self.allow_empty_file:
+            return True, None
+
+        return False, data

dynamicforms-0.77.8/dynamicforms/preupload_files.py

@@ -0,0 +1,117 @@
+import time
+
+from dataclasses import asdict, dataclass
+from typing import Optional
+from uuid import uuid4
+
+from django.core.cache import cache
+from django.utils.translation import gettext as __
+from rest_framework import status
+from rest_framework.exceptions import NotFound, PermissionDenied, ValidationError
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+# Cache constants
+CACHE_EXPIRATION = 60 * 60  # 60 minutes
+CACHE_KEY_PREFIX = "file_upload_"
+
+
+@dataclass
+class CachedFile:
+    content: bytes
+    name: str
+    content_type: str
+    size: int
+    user_id: int
+    timestamp: int
+
+    @property
+    def age_in_seconds(self) -> int:
+        return int(time.time()) - self.timestamp
+
+
+def count_user_cached_files(user_id: int) -> int:
+    """Vrne število vseh cached datotek za uporabnika"""
+    count = 0
+
+    if hasattr(cache, 'keys'):  # we expect redis in production
+        for key in cache.keys(f"{CACHE_KEY_PREFIX}*"):
+            file_data = cache.get(key)
+            if file_data and file_data.get("user_id") == user_id:
+                count += 1
+
+    return count
+
+class FileUploadView(APIView):
+    def post(self, request):
+        """Upload file to cache storage"""
+        MAX_FILE_SIZE = 1 * 1024 * 1024  # 1MB
+        MAX_FILES_PER_USER = 10
+
+        uploaded_file = request.FILES.get("file")
+        if not uploaded_file:
+            raise ValidationError({"file": ["required"]})
+
+        if uploaded_file.size > MAX_FILE_SIZE:
+            msg = __("File size exceeds allowed maximum size of {size_mb}MB")
+            raise ValidationError({"file": [msg.format(size_mb=MAX_FILE_SIZE // (1024 * 1024))]})
+
+        user_id = request.user.id or -1
+
+        if count_user_cached_files(user_id) >= MAX_FILES_PER_USER:
+            raise ValidationError({"file": [__("Too many files uploaded. Please submit a form or try again later.")]})
+
+        try:
+            file_identifier = str(uuid4())
+            file_content = uploaded_file.read()
+
+            cached_file = CachedFile(
+                content=file_content,
+                name=uploaded_file.name,
+                content_type=uploaded_file.content_type,
+                size=uploaded_file.size,
+                user_id=user_id,
+                timestamp=int(time.time()),
+            )
+
+            cache_key = f"{CACHE_KEY_PREFIX}{file_identifier}"
+            cache.set(cache_key, asdict(cached_file), CACHE_EXPIRATION)
+
+            return Response({"identifier": file_identifier})
+
+        except Exception as e:
+            # V produkciji uporabi proper logging
+            print(f"Error during file upload: {str(e)}")
+            return Response({"error": __("File upload failed")}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    def delete(self, request, file_identifier=None):
+        """Delete file from cache storage"""
+        if not file_identifier:
+            raise ValidationError({"file_identifier": ["required"]})
+
+        file_identifier = file_identifier.rstrip("/")  # remove the trailing slash
+        cached_file = get_cached_file(file_identifier, request.user.id)
+        if not cached_file:
+            raise NotFound(__("File not found"))
+
+        cache_key = f"{CACHE_KEY_PREFIX}{file_identifier}"
+        cache.delete(cache_key)
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+def get_cached_file(file_identifier: str, user_id: int, delete_from_cache: bool = False) -> Optional[CachedFile]:
+    """Helper function to retrieve file from cache"""
+    cache_key = f"{CACHE_KEY_PREFIX}{file_identifier}"
+    file_data = cache.get(cache_key)
+
+    if not file_data:
+        return None
+
+    if file_data.get("user_id") != user_id:
+        raise PermissionDenied(__("You don't have permission to access this file"))
+
+    if delete_from_cache:
+        cache.delete(cache_key)
+
+    return CachedFile(**file_data)

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/dynamicforms/serializers.py

@@ -303,10 +303,14 @@ class ModelSerializer(DynamicFormsSerializer, serializers.ModelSerializer):
         resolved display value in table
         """
         for field_name in field_names[:]:
-            # serializer field: either what is declared as a Field instance in Serializer or AutogeneratedField
-            s_field = declared_fields.get(field_name, getattr(self, field_name, None))
             # existing extra as provided by get_extra_kwargs
             extra = extra_kwargs.get(field_name, dict())
+
+            # serializer field: either what is declared as a Field instance in Serializer or AutogeneratedField
+            s_field = declared_fields.get(field_name, getattr(self, field_name, None))
+            if isinstance(s_field, fields.AutoGeneratedField):
+                s_field = s_field.get_serializer_field(field_name, self, extra)
+
             # model field, if it exists
             try:
                 d_field = self.Meta.model._meta.get_field(field_name)
@@ -350,7 +354,7 @@ class ModelSerializer(DynamicFormsSerializer, serializers.ModelSerializer):
                     source="*",
                     display_form=DisplayMode.HIDDEN,
                     display_table=DisplayMode.FULL,
-                    render_params=s_field.render_params if s_field else None,
+                    render_params=getattr(s_field, "render_params", None) if s_field else None,
                 )
 
                 def get_resolve_method(fld_nm, res_fld):
@@ -528,4 +532,3 @@ class DynamicModelSerializerMixin(DynamicModelMixin):
         except ImportError:
             pass
         return self.Meta.layout
-

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/dynamicforms/urls.py

@@ -5,5 +5,5 @@ from dynamicforms import preupload_files, progress
 urlpatterns = [
     # Progress is used for checking on progress of operation on server
     re_path(r"^progress/$", progress.get_progress_value, name="progress"),
-    re_path(r"^preupload-file/$", preupload_files.preupload_file, name="preupload-file"),
+    re_path(r"^preupload-file/(?P<file_identifier>[\w-]+/)?$", preupload_files.FileUploadView.as_view(), name="preupload-file"),
 ]

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/examples/rest/advanced_fields.py

@@ -5,7 +5,6 @@ from dynamicforms.template_render.layout import Layout
 from dynamicforms.viewsets import ModelViewSet
 
 from ..models import AdvancedFields, Relation
-from .fields.df_file_field import DfFileField, DfPreloadedFileField
 
 
 class AdvancedFieldsSerializer(serializers.ModelSerializer):
@@ -95,8 +94,8 @@ class AdvancedFieldsSerializer(serializers.ModelSerializer):
         queryset=Relation.objects.all(), url_reverse="relation-list", value_field="id", text_field="name"
     )
     slug_related_field = fields.SlugRelatedField(slug_field="name", queryset=Relation.objects.all())
-    file_field = DfFileField(max_length=None, allow_empty_file=False, use_url=False, allow_null=True, required=False)
-    file_field_two = DfPreloadedFileField(allow_empty_file=False, use_url=False, allow_null=True, required=False)
+    file_field = fields.FileField(max_length=None, allow_empty_file=False, use_url=False, allow_null=True, required=False)
+    file_field_two = fields.FileField(allow_empty_file=False, use_url=False, allow_null=True, required=False)
 
     # hyperlinked_identity_field = serializers.HyperlinkedIdentityField(view_name='relation-detail', read_only=True)
 

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/examples/rest/document.py

@@ -1,8 +1,7 @@
-from dynamicforms import serializers
+from dynamicforms import fields, serializers
 from dynamicforms.viewsets import ModelViewSet
 
 from ..models import Document
-from .fields.df_file_field import DfPreloadedFileField
 
 
 class DocumentsSerializer(serializers.ModelSerializer):
@@ -13,7 +12,7 @@ class DocumentsSerializer(serializers.ModelSerializer):
         "edit": "Editing document object",
     }
 
-    file = DfPreloadedFileField(allow_empty_file=False, use_url=False, allow_null=True)
+    file = fields.FileField(allow_empty_file=False, use_url=False, allow_null=True)
 
     class Meta:
         model = Document

{dynamicforms-0.77.4 → dynamicforms-0.77.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dynamicforms"
-version = "0.77.4"
+version = "0.77.8"
 description = "DynamicForms performs all the visualisation & data entry of your DRF Serializers & ViewSets and adds some candy of its own"
 readme = "README.md"
 requires-python = ">=3.8"

dynamicforms-0.77.4/dynamicforms/preupload_files.py

@@ -1,42 +0,0 @@
-import pathlib
-import time
-
-from typing import Optional
-from uuid import uuid4
-
-from django.conf import settings
-from django.core.files.storage import FileSystemStorage
-from django.core.files.uploadedfile import InMemoryUploadedFile
-from django.http import HttpResponse, JsonResponse
-from django.utils.translation import gettext as __
-from rest_framework import status
-from rest_framework.exceptions import ValidationError
-
-UPLOADED_FILE_NAME_TIMESTAMP_SEPARATOR = "_timestamp_"
-UPLOADED_FILE_NAME_UUID_SEPARATOR = "_uuid_"
-UPLOADED_FILE_TMP_LOCATION = "df_tmp_files"
-
-preuploaded_fs = FileSystemStorage(location=f"{settings.MEDIA_ROOT}/{UPLOADED_FILE_TMP_LOCATION}")
-
-
-def preupload_file(request):
-    # if not DYNAMICFORMS.allow_anonymous_user_to_preupload_files and not request.user.is_authenticated:
-    #     return HttpResponse(status=status.HTTP_401_UNAUTHORIZED)
-    if request.method == "POST":
-        uploaded_file: Optional[InMemoryUploadedFile] = request.FILES.get("file", None)
-        if not uploaded_file:
-            raise ValidationError(dict(file=["required"]))
-        file_identifier: str = str(uuid4())
-        try:
-            file_extension: str = pathlib.Path(uploaded_file.name).suffix
-            file_name: str = uploaded_file.name.replace(file_extension, "")
-            preuploaded_fs.save(
-                f"{file_name}{UPLOADED_FILE_NAME_UUID_SEPARATOR}{file_identifier}"
-                f"{UPLOADED_FILE_NAME_TIMESTAMP_SEPARATOR}{int(time.time())}"
-                f"{file_extension}",
-                uploaded_file,
-            )
-            return JsonResponse(dict(identifier=file_identifier))
-        except Exception:
-            return HttpResponse(status=status.HTTP_500_INTERNAL_SERVER_ERROR, content=__("File upload failed").encode())
-    return HttpResponse(status=status.HTTP_501_NOT_IMPLEMENTED)

dynamicforms-0.77.4/dynamicforms_legacy/mixins/file_field.py

@@ -1,5 +0,0 @@
-class FileFieldMixin(object):
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
-        # noinspection PyUnresolvedReferences
-        self.style.setdefault("no_filter", True)

dynamicforms-0.77.4/examples/rest/fields/df_file_field.py

@@ -1,76 +0,0 @@
-import glob
-import os
-import pathlib
-
-from typing import Optional
-
-from django.core.files.uploadedfile import InMemoryUploadedFile
-from django.utils.safestring import mark_safe
-from django.utils.translation import gettext_lazy as _
-from rest_framework.exceptions import ValidationError
-
-from dynamicforms.fields import FileField
-from dynamicforms.preupload_files import (
-    preuploaded_fs,
-    UPLOADED_FILE_NAME_TIMESTAMP_SEPARATOR,
-    UPLOADED_FILE_NAME_UUID_SEPARATOR,
-)
-
-
-class DfFileField(FileField):
-    def to_representation(self, value, row_data=None):
-        empty_value: Optional[str] = ""
-        render_to_component_def_format: bool = self.context.get("format", "") == "componentdef"
-        if render_to_component_def_format:
-            empty_value = None
-        if not value:
-            return empty_value
-        link = mark_safe(
-            '<a href="#" onclick=\'dynamicforms.stopEventPropagation(event); window.open("%s", "_blank")\'>%s</a>'
-            % (value.url, os.path.basename(value.url))
-        )
-        self.help_text = "Existing file: %s " % link
-        return super().to_representation(empty_value, row_data)
-
-    def render_to_table(self, value, row_data):
-        render_to_component_def_format: bool = self.context.get("format", "") == "componentdef"
-        link = mark_safe(
-            '<a href="#" onclick=\'dynamicforms.stopEventPropagation(event); window.open("%s", "_blank")\'>%s</a>'
-            % (value.url, os.path.basename(value.url))
-        )
-        return link if not render_to_component_def_format else value.url
-
-
-class DfPreloadedFileField(FileField):
-    def to_representation(self, value, row_data=None):
-        if value:
-            return getattr(value, "url", None)
-        return None
-
-    def to_internal_value(self, data):
-        if not isinstance(data, str):
-            raise ValidationError(_("File identifier should be string"))
-        file_size = len(data)
-        if not self.allow_empty_file and not file_size:
-            self.fail("empty")
-        file: Optional[str] = next(
-            iter(
-                glob.glob(
-                    f"{preuploaded_fs.location}/*{UPLOADED_FILE_NAME_UUID_SEPARATOR}*{data}*{UPLOADED_FILE_NAME_TIMESTAMP_SEPARATOR}*"
-                )
-            ),
-            None,
-        )
-        if not file and self.parent.instance and getattr(self.parent.instance, self.field_name, None):
-            return str(getattr(self.parent.instance, self.field_name))
-        file_object = pathlib.Path(file)
-        file_pointer = open(file, "rb")
-        return InMemoryUploadedFile(
-            file=file_pointer,
-            field_name=self.field_name,
-            name=f"{file_object.stem.split(UPLOADED_FILE_NAME_UUID_SEPARATOR)[0]}{file_object.suffix}",
-            content_type=None,
-            size=len(file_pointer.read()),
-            charset=None,
-            content_type_extra=None,
-        )