dynamicforms 0.76.14__py3-none-any.whl

dynamicforms/mixins/related_field_ajax.py

@@ -0,0 +1,142 @@
+import sys
+
+from typing import Optional
+
+from django.db.models.manager import BaseManager
+from django.urls import reverse
+from django.utils.http import urlencode
+from rest_framework.relations import RelatedField
+
+
+class RelatedFieldAJAXMixin(object):
+    def __init__(
+        self,
+        *args,
+        url_reverse: Optional[str] = None,
+        placeholder: Optional[str] = None,
+        additional_parameters: Optional[dict] = None,
+        query_field: str = "query",
+        value_field: str = "choice_id",
+        text_field: str = "choice_text",
+        **kwargs,
+    ):
+        """
+        Allows us to use AJAX to populate select2 options instead of pre-populating at render time
+
+        :param args:
+        :param url_reverse: reverse url to ViewSet providing the JSON data
+        :param placeholder: select2 placeholder to display until user selects a value
+        :param additional_parameters: additional parameters to be sent to ViewSet as part of the query
+        :param query_field: field against which user search will be performed
+        :param kwargs:
+        """
+        super().__init__(*args, **kwargs)
+        self.url_reverse = url_reverse
+        self.placeholder = placeholder
+        self.additional_parameters = additional_parameters
+        self.query_field = query_field
+        self.value_field = value_field
+        self.text_field = text_field
+
+    @property
+    def additional_parameters_urlencoded(self):
+        return urlencode(self.additional_parameters) if self.additional_parameters else None
+
+    # noinspection PyUnresolvedReferences
+    def iter_options_bound(self, value):
+        if self.url_reverse:
+            if value is None:
+                return [dict(value="", display_text=self.placeholder)]
+            try:
+                if hasattr(self, "child_relation"):
+                    itm = self.child_relation
+                    qry = itm.get_queryset()
+                    if value != "__all__":
+                        qry = qry.filter(pk__in=value)
+                else:
+                    itm = self
+                    qry = self.get_queryset()
+                    if value != "__all__":
+                        qry = qry.filter(pk=value)
+
+                return [dict(value=rec.id, display_text=itm.display_value(rec)) for rec in qry.all()]
+            except:
+                return []
+        return super().iter_options()
+
+    def as_component_def(self) -> dict:
+        try:
+            res = super().as_component_def()  # noqa
+        except AttributeError:
+            res = dict()
+        if self.url_reverse:
+            ajax = dict(
+                ajax=dict(
+                    url_reverse=reverse(self.url_reverse, kwargs=dict(format="json")),
+                    placeholder=self.placeholder,
+                    additional_parameters=self.additional_parameters_urlencoded,
+                    query_field=self.query_field,
+                    value_field=self.value_field,
+                    text_field=self.text_field,
+                )
+            )
+            res.update(ajax)
+            qs_count = self.get_queryset().count()
+
+            if qs_count and qs_count <= 10:
+                res.update(
+                    choices=map(
+                        lambda option: dict(id=option["value"], text=option["display_text"]),
+                        self.iter_options_bound("__all__"),
+                    )
+                )
+        else:
+            res.update(
+                choices=list(map(
+                    lambda option: dict(id=option.value, text=option.display_text), self.iter_options_bound(None)
+                )
+            ))
+            if len(res["choices"]) > 100:
+                print(
+                    f"WARNING: {self.parent.__class__.__name__}.{self.field_name} should be converted to AJAX.",
+                    file=sys.stderr
+                )
+        return res
+
+    # noinspection PyUnusedLocal, PyUnresolvedReferences
+    def render_to_table(self, value, row_data):
+        """
+        Renders field value for table view :if rendering to html table, let's try to resolve any lookups
+        hidden fields will render to tr data-field_name attributes, so we maybe want to have ids, not text there,
+          but that's up to front end to decide
+
+        :param value: field value
+        :param row_data: data for entire row (for more complex renderers)
+        :return: rendered value for table view
+        """
+        from dynamicforms.fields import ManyRelatedField
+
+        if isinstance(self, ManyRelatedField):
+            # Hm, not sure if this is the final thing to do: an example of this field is in
+            # ALC plane editor (modes of takeoff). However, value is a queryset here. There seem to still be DB queries
+            # However, in the example I have, the problem is solved by doing prefetch_related on the m2m relation
+            cr = self.child_relation
+            if isinstance(value, BaseManager):
+                value = value.all()
+            if value is None:
+                return ""
+            return ", ".join((cr.display_value(item) for item in value))
+            # return ', '.join((cr.display_value(item) for item in cr.get_queryset().filter(pk__in=value)))
+        elif isinstance(self, RelatedField):
+            return self.display_value(value)
+
+        return value
+
+    @classmethod
+    def many_init(cls, *args, **kwargs):
+        list_kwargs = {"child_relation": cls(*args, **kwargs)}
+        from dynamicforms.fields import ManyRelatedField
+
+        return ManyRelatedField(
+            display_form=kwargs.get("display_form"), display_table=kwargs.get("display_table"), **list_kwargs
+        )

dynamicforms/mixins/rtf_field.py

@@ -0,0 +1,58 @@
+from html.parser import HTMLParser
+
+
+class RTFFieldMixin(object):
+    def __init__(self, *args, show_as_plain_text=False, plain_text_lines=3, plain_text_line_length=40, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse = show_as_plain_text or False
+        self.max_lines = plain_text_lines
+        self.max_line_length = plain_text_line_length
+        self.parser = RTFFieldHTMLParser(max_lines=self.max_lines, max_line_length=self.max_line_length)
+
+    def to_representation(self, instance, row_data=None):
+        # TODO: why is this here and not in init?
+        self.style.update(input_type="input")
+        if not self.parent.is_filter:
+            self.render_params["form_component_name"] = "DCKEditor"
+
+        return super().to_representation(instance, row_data)
+
+    def render_to_table(self, value, row_data):
+        if not self.parent.is_filter and self.parse:
+            self.parser.feed(value)
+            instance = self.parser.to_string()
+            self.parser.reset()
+            return instance
+        return value
+
+
+class RTFFieldHTMLParser(HTMLParser):
+    def __init__(self, max_lines, max_line_length):
+        self.text = []
+        self.curr_line_count = 1
+        self.curr_line = ""
+        self.max_lines = max_lines
+        self.max_line_length = max_line_length
+        super(RTFFieldHTMLParser, self).__init__()
+
+    def handle_data(self, data):
+        text = data.strip()
+        if self.curr_line_count <= self.max_lines:
+            if len(text) > 0:
+                self.curr_line += " " + text
+                line = self.curr_line[0 : self.max_line_length - 3]
+                if len(self.curr_line) >= self.max_line_length - 3:
+                    line += "..."
+                line += "<br>"
+                self.text.append(line)
+                self.curr_line = ""
+                self.curr_line_count += 1
+
+    def reset(self):
+        self.text = []
+        self.curr_line_count = 1
+        self.curr_line = ""
+        super(RTFFieldHTMLParser, self).reset()
+
+    def to_string(self):
+        return "".join(self.text).strip()

dynamicforms/models.py

@@ -0,0 +1,5 @@
+# supposedly required so that tests & stuff works
+
+# from django.db import models
+
+# Create your models here.

dynamicforms/models_utils.py

@@ -0,0 +1,33 @@
+from enum import IntEnum
+
+
+class IntChoiceEnum(IntEnum):
+    def __new__(cls, *args, **kwargs):
+        obj = int.__new__(cls, args[0])
+        obj._value_ = args[0]
+        return obj
+
+    # ignore the first param since it's already set by new
+    def __init__(self, _: str, description: str = None, icon: str = None, data: dict = None):
+        self._description_ = description
+        self._icon_ = icon
+        self._data_ = data
+
+    description = property(lambda self: self._description_)
+    icon = property(lambda self: self._icon_)
+    data = property(lambda self: self._data_)
+
+    @classmethod
+    def get_choices_tuple(cls):
+        return tuple((item.value, item.description) for item in cls)
+
+    @classmethod
+    def get_df_tuple(cls):
+        return tuple(
+            (item.value, item.description, item.icon) if item.icon is not None else (item.value, item.description)
+            for item in cls
+        )
+
+    @classmethod
+    def has_value(cls, value):
+        return value in cls.__members__.values()

dynamicforms/pagination.py

@@ -0,0 +1,175 @@
+import datetime
+import json
+
+import rest_framework.pagination as drf_p
+
+from django.db.models import DurationField, F, Q
+
+
+class CursorPagination(drf_p.CursorPagination):
+    ordering = "pk"
+    NONE_VALUE = "{`None`}"
+
+    # noinspection PyAttributeOutsideInit
+    def paginate_queryset(self, queryset, request, view=None):
+        self.page_size = self.get_page_size(request)
+        if not self.page_size:
+            return None
+
+        self.base_url = request.build_absolute_uri()
+        self.ordering = self.get_ordering(request, queryset, view)
+        if "id" not in self.ordering and "-id" not in self.ordering:
+            ordering = list(self.ordering)
+            ordering.append("id")
+            self.ordering = tuple(ordering)
+
+        self.cursor = self.decode_cursor(request)
+        if self.cursor is None:
+            (offset, reverse, current_position) = (0, False, None)
+        else:
+            (offset, reverse, current_position) = self.cursor
+        try:
+            if current_position:
+                current_position = json.loads(current_position)
+        except TypeError:
+            current_position = None
+
+        # Cursor pagination always enforces an ordering.
+        ordering = drf_p._reverse_ordering(self.ordering) if reverse else self.ordering
+        # Currently we force nulls_first in ascending order and nulls_last in descending order
+        ordering = [
+            getattr(F(field.lstrip("-")), "desc" if field.startswith("-") else "asc")(
+                **{"nulls_last" if field.startswith("-") else "nulls_first": True}
+            )
+            for field in ordering
+        ]
+        queryset = queryset.order_by(*ordering)
+
+        # If we have a cursor with a fixed position then filter by that.
+        if current_position is not None:
+
+            def filter_segment(segment_len):
+                kwargs = {}
+                args = []
+                for idx in range(segment_len):
+                    order = self.ordering[idx]
+                    is_reversed = order.startswith("-")
+                    order_attr = order.lstrip("-")
+                    attr_value = self.field_to_python(queryset, order_attr, current_position[order_attr])
+
+                    # Test for: (cursor reversed) XOR (queryset reversed)
+                    if idx < segment_len - 1:
+                        # if this is the last field in this segment
+                        if attr_value == self.NONE_VALUE:
+                            kwargs[order_attr + "__isnull"] = True
+                        else:
+                            kwargs[order_attr] = attr_value
+                    elif self.cursor.reverse != is_reversed:
+                        if attr_value == self.NONE_VALUE:
+                            # It is impossible to go lower than None... so we just omit this segment
+                            return None
+                        else:
+                            args.append(Q(**{order_attr + "__lt": attr_value}) | Q(**{order_attr + "__isnull": True}))
+                    else:
+                        if attr_value == self.NONE_VALUE:
+                            kwargs[order_attr + "__isnull"] = False
+                        else:
+                            kwargs[order_attr + "__gt"] = attr_value
+
+                return Q(**kwargs) & Q(*args)
+
+            fltr = Q()
+            for seg_len in range(len(self.ordering)):
+                new_segment = filter_segment(seg_len + 1)
+                if new_segment:
+                    fltr = fltr | new_segment
+            queryset = queryset.filter(fltr)
+
+        # If we have an offset cursor then offset the entire page by that amount.
+        # We also always fetch an extra item in order to determine if there is a
+        # page following on from this one.
+        results = list(queryset[offset : offset + self.page_size + 1])
+        self.page = list(results[: self.page_size])
+        if not self.page:
+            # In rest_framework/pagination.py/get_previous_link is expected that self.page is not empty
+            # if cursor offset != 0
+            self.cursor = drf_p.Cursor(offset=0, reverse=False, position=None)
+
+        # DF: contrary to DRF's implementation we always provide the "prev" and "next" links as there may appear
+        # new records before / after the ones we already read. Mechanism for detecting whether they actually appeared
+        # is another matter altogether :)
+        if current_position is None and results:
+            self.cursor = drf_p.Cursor(offset=0, reverse=False, position=None)
+            current_position = self._get_position_from_instance(results[0], self.ordering)
+        elif isinstance(current_position, dict):
+            current_position = json.dumps(current_position)
+
+        # Determine the position of the final item following the page.
+        has_following_position = bool(results)  # len(results) > len(self.page)
+
+        # DF: contrary to DRF's implementation we always provide the "next" link as there may appear new records after
+        # the last one read
+        following_position = self._get_position_from_instance(results[-1], self.ordering) if results else None
+
+        if reverse:
+            # If we have a reverse queryset, then the query ordering was in reverse
+            # so we need to reverse the items again before returning them to the user.
+            self.page = list(reversed(self.page))
+
+            # Determine next and previous positions for reverse cursors.
+            self.has_next = (current_position is not None) or (offset > 0)
+            self.has_previous = has_following_position
+            if self.has_next:
+                self.next_position = current_position
+            if self.has_previous:
+                self.previous_position = following_position
+        else:
+            # Determine next and previous positions for forward cursors.
+            self.has_next = has_following_position
+            self.has_previous = (current_position is not None) or (offset > 0)
+            if self.has_next:
+                self.next_position = following_position
+            if self.has_previous:
+                self.previous_position = current_position
+
+        # Display page controls in the browsable API if there is more
+        # than one page.
+        if (self.has_previous or self.has_next) and self.template is not None:
+            self.display_page_controls = True
+
+        return self.page
+
+    def _get_position_from_instance(self, instance, ordering):
+        def process_field(idx):
+            field_name = ordering[idx].lstrip("-")
+            attr = None
+            if isinstance(instance, dict):
+                attr = instance[field_name]
+            else:
+                field_name_list = field_name.split("__")
+                for fn in field_name_list:
+                    attr = getattr(instance if attr is None else attr, fn)
+            return field_name, self.field_to_representation(attr)
+
+        return json.dumps({k: v for k, v in map(lambda idx: process_field(idx), range(len(ordering)))})
+
+    def field_to_representation(self, value):
+        """
+        Converts field value to something that will be later understood by QuerySet.filter()
+        Question: why does DRF not do this? is str(value) always enough?
+        """
+        if isinstance(value, datetime.timedelta):
+            return str(value.total_seconds())
+        elif value is None:
+            return self.NONE_VALUE
+        return str(value)
+
+    def field_to_python(self, queryset, order_attr, value):
+        if order_attr in queryset.query.annotations:
+            field = queryset.query.annotations.get(order_attr).field
+        else:
+            # noinspection PyProtectedMember
+            field = queryset.model._meta.get_field(order_attr)
+        if isinstance(field, DurationField):
+            return datetime.timedelta(seconds=float(value))
+        return value

dynamicforms/preupload_files.py

@@ -0,0 +1,42 @@
+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/progress.py

@@ -0,0 +1,71 @@
+from django.core.cache import cache
+from django.http import HttpResponse
+from rest_framework.renderers import JSONRenderer
+
+
+def get_progress_value(request):
+    """
+    Returns operations progress to HTTP client
+
+    :param request:
+    :return: Progress in percentages (0 - 100) if progress is set else None
+    """
+    progress_key = get_progress_key(request)
+    value = None
+    if progress_key is not None:
+        cache_value = cache.get("df_progress.%s" % progress_key)
+        if cache_value is not None:
+            value = "%.2f" % cache.get("df_progress.%s" % progress_key)
+
+    return HttpResponse(
+        JSONRenderer().render(dict(value=value, comment=cache.get("df_progress_comment.%s" % progress_key))),
+        content_type="application/json",
+    )
+
+
+def get_progress_key(request):
+    """
+    Gets progress/operation key under which operation progress will be stored in servers cache.
+    :param request:
+    :return: Progress key or None if there is no x_df_timestamp in request header
+    """
+    timestamp = request.META.get("HTTP_X_DF_TIMESTAMP", request.GET.get("x_df_timestamp", None))
+    if timestamp is not None:
+        return "%s|%s" % (timestamp, request.session.session_key)
+    return None
+
+
+def set_progress_value(progress_key, value):
+    """
+    Updates operations progress
+
+    :param progress_key: Key under which operations progress is stored
+    :param value: Progress in percentages (0.00 - 100.00)
+    :return:
+    """
+    if progress_key is not None:
+        cache.set("df_progress.%s" % progress_key, value)
+
+
+def add_progress_value(progress_key, value):
+    """
+    Updates operations progress by adding to existing progress value
+
+    :param progress_key: Key under which operations progress is stored
+    :param value: Progress in percentages (0.00 - 100.00)
+    :return:
+    """
+    if progress_key is not None:
+        cache.set("df_progress.%s" % progress_key, cache.get("df_progress.%s" % progress_key, 0) + value)
+
+
+def set_progress_comment(progress_key, value):
+    """
+    Updates operations comment
+
+    :param progress_key: Key under which operations progress is stored
+    :param value: comment
+    :return:
+    """
+    if progress_key is not None:
+        cache.set("df_progress_comment.%s" % progress_key, value)

dynamicforms/renderers.py

@@ -0,0 +1 @@
+from .template_render import ComponentDefRenderer  # noqa: F401

dynamicforms/routers.py

@@ -0,0 +1,36 @@
+from typing import Optional, Set
+
+from rest_framework.routers import DefaultRouter, Route
+
+from dynamicforms.viewsets import SingleRecordViewSet
+
+
+class DFRouter(DefaultRouter):
+    single_record_registrations: Set[int] = set()
+
+    def register_single_record(self, prefix: str, viewset: SingleRecordViewSet, basename: Optional[str] = None):
+        """
+        Register a single-record viewset with the router.
+        """
+        self.single_record_registrations.add(id(viewset))
+        self.register(prefix, viewset, basename)
+
+    def get_routes(self, viewset):
+        if id(viewset) in self.single_record_registrations:
+            # these routes are copied from SimpleRouter, but modified so that they don't ask for a parameter
+            return [
+                Route(
+                    url=r"^{prefix}{trailing_slash}$",
+                    mapping={
+                        "post": "create",
+                        "get": "retrieve",
+                        "put": "update",
+                        "patch": "partial_update",
+                        "delete": "destroy",
+                    },
+                    name="{basename}-detail",
+                    detail=True,
+                    initkwargs={"suffix": "Instance"},
+                ),
+            ]
+        return super().get_routes(viewset)