dynamicforms 0.76.14__py3-none-any.whl

dynamicforms_legacy/mixins/rtf_field.py

@@ -0,0 +1,52 @@
+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):
+        if not self.parent.is_filter:
+            self.style.update({"base_template": "rtf_field.html"})
+        if self.is_rendering_to_list and not self.parent.is_filter and self.parse:
+            self.parser.feed(instance)
+            instance = self.parser.to_string()
+            self.parser.reset()
+
+        return super().to_representation(instance, row_data)
+
+
+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_legacy/mixins/single_choice.py

@@ -0,0 +1,21 @@
+from .render import DisplayMode
+
+
+class SingleChoiceMixin:
+    def __init__(self, *args, single_choice_hide=False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.single_choice_hide = single_choice_hide
+
+    def to_internal_value(self, data):
+        if self.single_choice_hide and len(self.choices) == 1:
+            data = list(self.choices)[0]
+        elif self.single_choice_hide and len(self.choices) < 1:
+            data = None
+        return super().to_internal_value(data)
+
+    def set_single_choice_hide(self, value):
+        self._single_choice_hide = value
+        if value and len(self.choices) <= 1:
+            self.display_form = DisplayMode.HIDDEN
+
+    single_choice_hide = property(lambda self: self._single_choice_hide, set_single_choice_hide)

dynamicforms_legacy/models.py

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

dynamicforms_legacy/pagination.py

@@ -0,0 +1,168 @@
+import datetime
+import json
+
+import rest_framework.pagination as drf_p
+
+from django.db.models import DurationField, 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.
+        if reverse:
+            queryset = queryset.order_by(*drf_p._reverse_ordering(self.ordering))
+        else:
+            queryset = queryset.order_by(*self.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 = {}
+                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:
+                            kwargs[order_attr + "__isnull"] = False
+                        else:
+                            kwargs[order_attr + "__lt"] = attr_value
+                    else:
+                        if attr_value == self.NONE_VALUE:
+                            # It just doesn't go higher than None... so we use some impossible to reach filter
+                            kwargs["id"] = -1
+                        else:
+                            kwargs[order_attr + "__gt"] = attr_value
+
+                return Q(**kwargs)
+
+            fltr = Q()
+            for seg_len in range(len(self.ordering)):
+                fltr = fltr | filter_segment(seg_len + 1)
+
+            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 = True  # 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_legacy/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_legacy/renderers.py

@@ -0,0 +1,183 @@
+import copy
+
+import six
+
+from django.template import loader
+from django.utils.safestring import mark_safe
+from rest_framework.renderers import HTMLFormRenderer, TemplateHTMLRenderer
+from rest_framework.serializers import HiddenField, ListSerializer
+from rest_framework.utils.serializer_helpers import ReturnDict, ReturnList
+
+from dynamicforms_legacy.fields import BooleanField
+
+from .settings import DYNAMICFORMS
+
+
+# noinspection PyRedeclaration
+class TemplateHTMLRenderer(TemplateHTMLRenderer):
+    """
+    Renderers serializer data into an HTML form.
+
+    If the serializer was instantiated without an object then this will
+    return an HTML form not bound to any object,
+    otherwise it will return an HTML form with the appropriate initial data
+    populated from the object.
+
+    Note that rendering of field and form errors is not currently supported.
+    """
+
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        link_next = link_prev = ""
+
+        if (
+            isinstance(data, dict)
+            and "next" in data
+            and "results" in data
+            and isinstance(data["results"], (ReturnList, ReturnDict))
+        ):
+            # This is in case of Pagination
+            link_next = mark_safe(data.get("next", ""))
+            link_prev = mark_safe(data.get("previous", ""))
+            data = data["results"]
+        if isinstance(data, (ReturnList, ReturnDict)):
+            ser = data.serializer
+            data = dict(
+                data=data,
+                serializer=ser.child if isinstance(ser, ListSerializer) else ser,
+                link_next=link_next,
+                link_prev=link_prev,
+            )
+
+            if getattr(ser, "_errors", {}):
+                # CAUTION: bad hacks start here. This should be removed at some point
+
+                # unmark exception from response because this was a validation error
+                # This will allow TemplateHTMLRenderer to still render the template as if it was without problems
+                # If this is not done, the only result user will see will be a 404 error without any details
+                response = renderer_context["response"]
+                response.exception = False
+
+                # result data should be object data otherwise nothing will render...
+                data["data"] = data["serializer"].data
+
+        return super().render(data, accepted_media_type, renderer_context)
+
+    def get_template_names(self, response, view):
+        if view.render_type == "page" and DYNAMICFORMS.page_template:
+            return [DYNAMICFORMS.page_template]
+        return super().get_template_names(response, view)
+
+    def get_template_context(self, data, renderer_context):
+        res = super().get_template_context(data, renderer_context)
+        view = renderer_context["view"]
+        if hasattr(view, "template_context"):
+            if callable(view.template_context):
+                res.update(view.template_context())
+            else:
+                res.update(view.template_context)
+        res["df_render_type"] = view.render_type  # This one should not fail because it's set in initialize_request
+        res["DYNAMICFORMS"] = DYNAMICFORMS
+        return res
+
+
+# noinspection PyRedeclaration
+class HTMLFormRenderer(HTMLFormRenderer):
+    """
+    An HTML renderer for use with templates.
+
+    The data supplied to the Response object should be a dictionary that will
+    be used as context for the template.
+
+    The template name is determined by (in order of preference):
+
+    1. An explicit `.template_name` attribute set on the response.
+    2. An explicit `.template_name` attribute set on this class.
+    3. The return result of calling `view.get_template_names()`.
+
+    For example:
+        data = {'users': User.objects.all()}
+        return Response(data, template_name='users.html')
+    """
+
+    def render_field(self, field, parent_style):
+        # noinspection PyProtectedMember
+        if isinstance(field._field, HiddenField):
+            return ""
+
+        if isinstance(field._field, BooleanField):
+            # allow also null to have max values available for determening the right value to render
+            allow_null = copy.copy(field._field.allow_null)
+            field._field.allow_null = True
+            field.value = field._field.to_internal_value(field.value)
+            field._field.allow_null = allow_null
+
+        style = dict(self.default_style[field])
+        style.update(field.style)
+        if "template_pack" not in style:
+            style["template_pack"] = parent_style.get("template_pack", self.template_pack)
+        style["serializer"] = parent_style.get("serializer", None)
+        style["renderer"] = self
+
+        # Get a clone of the field with text-only value representation.
+        field = field.as_form_field()
+
+        if style.get("input_type") == "datetime-local" and isinstance(field.value, six.text_type):
+            field.value = field.value.rstrip("Z")
+
+        if "template" in style:
+            template_name = style["template"]
+        else:
+            template_name = style["template_pack"].strip("/") + "/" + style["base_template"]
+
+        template = loader.get_template(template_name)
+        context = {
+            "field": field,
+            "style": style,
+            "DYNAMICFORMS": DYNAMICFORMS,
+        }
+        try:
+            context.update(style["serializer"].context["view"].template_context)
+        except:
+            pass
+        return template.render(context)
+
+    # Jure: had to copy this one over to support custom template as parameter + DF context variable
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        """
+        Render serializer data and return an HTML form, as a string.
+        """
+        renderer_context = renderer_context or {}
+        form = data.serializer
+
+        style = renderer_context.get("style", {})
+        style["template_pack"] = DYNAMICFORMS.template_root + "field"
+        style["renderer"] = self
+
+        template_pack = style["template_pack"].strip("/")
+
+        # getting the template to use
+        template_name = next(
+            (
+                x
+                for x in (  # Get the first specified template name as encountered
+                    style.get("form_template", None),  # template name from tag parameter
+                    getattr(self, "form_template", None),  # if ViewSet set the form_template member of this renderer
+                    getattr(form, "form_template", None),  # if Serializer has form_template member set
+                    template_pack + "/" + self.base_template,  # take default template from pack
+                )
+                if x
+            )
+        )
+
+        template = loader.get_template(template_name)
+        context = {
+            "form": form,
+            "style": style,
+            "DYNAMICFORMS": DYNAMICFORMS,
+        }
+        context.update(getattr(form, "template_context", {}))
+        try:
+            context.update(form.context["view"].template_context)
+        except:
+            pass
+        return template.render(context)