dynamicforms 0.76.14__py3-none-any.whl

dynamicforms/template_render/layout.py

@@ -0,0 +1,178 @@
+import uuid
+
+from typing import Dict, List, Optional, Tuple, TYPE_CHECKING, Union
+
+from rest_framework.serializers import Serializer as DRFSerializer
+
+from dynamicforms.fields import DFField, DisplayMode
+
+if TYPE_CHECKING:
+    from dynamicforms.serializers import Serializer
+
+
+class Field(object):
+    def __init__(self, field_name: str, render_format: Optional[str] = None):
+        self.field_name = field_name
+        self.render_format = render_format
+
+    def field_def(self, serializer: "Serializer") -> Union[DFField, DRFSerializer]:
+        return serializer.fields[self.field_name]
+
+    def as_component_def(self, serializer: "Serializer", fields: Dict):
+        field = self.field_def(serializer).as_component_def()
+
+        field["name"] = self.field_name
+        if self.render_format:
+            field["render_format"] = self.render_format
+        fields[self.field_name] = field
+        return field["name"]
+
+
+class Column(object):
+    def __init__(self, field: Union[Tuple[str, DFField], Field, str, None], width_classes: Optional[str] = None):
+        if isinstance(field, str):
+            self.field = Field(field)
+        elif isinstance(field, Field):
+            self.field = field
+        elif field is None and isinstance(self, Group):
+            # a Group might not have a field attached to it
+            self.field = field
+        else:
+            raise NotImplementedError(f"Unknown field type {field.__class__.__name__}")
+        self.width_classes = width_classes or ""
+        # TODO: It was a lot more useful when bootstrap was the front-end framework and this basically allowed to
+        #  specify how big a column was to be used. Needs to change to support the Vue / Vuetify components and
+        #  their props now. task: https://app.clickup.com/t/86bzw1k8f
+
+    def _get_laid_fields(self):
+        return {self.field.field_name} if self.field is not None else set()
+
+    def as_component_def(self, serializer: "Serializer", fields: Dict) -> Dict:
+        fld_def = self.field.as_component_def(serializer, fields) if self.field is not None else dict()
+        res = dict(type="column", field=fld_def)
+        if self.width_classes:
+            res["width_classes"] = self.width_classes
+        return res
+
+
+class Row(object):
+    def __init__(self, *columns: Union[Column, Field, str], component: str = None):
+        self.component = component or "FormRow"
+        self.columns: List[Column] = []
+        for column in columns:
+            if isinstance(column, str):
+                self.columns.append(Column(Field(column)))
+            elif isinstance(column, Field):
+                self.columns.append(Column(column))
+            elif isinstance(column, Column):
+                self.columns.append(column)
+            else:
+                raise NotImplementedError(f"Unknown column type {column.__class__.__name__}")
+
+    def _get_laid_fields(self):
+        return set().union(*(col._get_laid_fields() for col in self.columns))
+
+    def as_component_def(self, serializer: "Serializer", fields: Dict) -> dict:
+        return dict(
+            component=self.component, columns=[col.as_component_def(serializer, fields) for col in self.columns]
+        )
+
+
+class Layout(object):
+    def __init__(
+        self,
+        *rows: Row,
+        component_name: str = "df-form-layout",
+        columns: int = 1,
+        size: str = "",
+        header_classes: str = "",
+        auto_add_fields: bool = True,
+    ):
+        """
+        Creates layout definition
+        :param rows: layout rows containing columns & fields
+        :param columns: for all fields not added in layout manually, add them in n-column layout
+        :param size: 'small', 'large' or ''
+        :param header_classes: 'bg-info', ..., or ''
+        """
+        self.rows: List[Row] = list(rows) or []
+        self.columns = columns
+        self.size = size
+        self.header_classes = header_classes
+        self.component_name = component_name
+        self.auto_add_fields = auto_add_fields
+
+    def _get_laid_fields(self):
+        return set().union(*(row._get_laid_fields() for row in self.rows))
+
+    def as_component_def(self, serializer: "Serializer", fields: Dict = None, used_fields: set = None) -> Dict:
+        assert serializer is not None
+        fields = fields if fields is not None else dict()
+        res = dict(rows=[row.as_component_def(serializer, fields) for row in self.rows])
+        res["fields"] = fields
+        used_fields = (used_fields or set()).union(self._get_laid_fields())
+        if self.size:
+            res["size"] = self.size
+        if self.header_classes:
+            res["header_classes"] = self.header_classes
+
+        if self.auto_add_fields:
+            # add any non-declared fields and append them to the end of the layout
+            # if no layout is specified in serializer Meta, this will generate default single-column layout
+            default_layout = Layout()
+            row = []
+            row_num = 0
+            for field_name, field in serializer.fields.items():
+                if field_name not in used_fields and field.display_form != DisplayMode.SUPPRESS:
+                    used_fields.add(field_name)
+                    row.append(
+                        Group(field_name)  # nested Serializer or ListSerializer
+                        if isinstance(field, DRFSerializer)
+                        else field_name  # "just" a standard field
+                    )
+                    if field.display_form == DisplayMode.FULL:
+                        row_num += 1
+                    if row_num >= self.columns:
+                        default_layout.rows.append(Row(*row))
+                        row, row_num = [], 0
+            if row:
+                default_layout.rows.append(Row(*row))
+            if default_layout.rows:
+                res["rows"] += default_layout.as_component_def(serializer, fields, used_fields)["rows"]
+
+        res["component_name"] = self.component_name
+        return res
+
+
+class Group(Column):
+    def __init__(
+        self,
+        field: Union[str, Field, None],
+        title: str = None,
+        sub_layout: Layout = None,
+        width_classes: Optional[str] = None,
+        footer: Optional[str] = None,
+    ):
+        super().__init__(field, width_classes)
+        self.title = title
+        self.layout = sub_layout
+        self.footer = footer
+
+    def _get_laid_fields(self):
+        if self.field is None:
+            return self.layout._get_laid_fields()
+        return super()._get_laid_fields()
+
+    def as_component_def(self, serializer: "Serializer", fields: Dict) -> Dict:
+        res = super().as_component_def(serializer, fields)
+        assert self.field or self.layout
+        sub_serializer = self.field.field_def(serializer) if self.field else None  # type: Serializer
+        layout = self.layout or sub_serializer.layout
+        res.update(
+            type="group",
+            footer=self.footer,
+            title=self.title or sub_serializer.label,
+            uuid=sub_serializer.uuid if sub_serializer else uuid.uuid4(),
+            layout=layout.as_component_def(sub_serializer if sub_serializer else serializer),
+        )
+        return res

dynamicforms/template_render/mixins/base.py

@@ -0,0 +1,39 @@
+from dynamicforms.fields import DFField
+
+from .render_mode_enum import ViewModeEnum
+
+
+class ViewModeBase(object):
+    view_mode = None
+
+    def set_view_mode(self, view_mode: "ViewModeEnum"):
+        self.view_mode = view_mode
+
+    def set_bound_value(self, *args):
+        """
+        Used to set the bound value. However, implementation is class-specific, so we only declare this so that
+        implementations are checked to contain the method
+        """
+        raise NotImplementedError()
+
+    def render(self: "_ViewModeBoundField"):
+        view_mode_name = f"render_{self.view_mode.name.lower()}"
+        render_func = getattr(self, view_mode_name, None)
+        if render_func is None:
+            raise NotImplementedError(
+                f'ViewMode object {self.__class__.__name__}{(" " + self.label) if self.label else ""} has view_mode '
+                f"set to {self.view_mode.name}, but doesn't handle rendering for it"
+            )
+        return render_func()
+
+    def __str__(self):
+        return self.render()
+
+
+# noinspection PyAbstractClass
+class _ViewModeBoundField(ViewModeBase, DFField):
+    """
+    Dummy class just for type hinting
+    """
+
+    pass

dynamicforms/template_render/mixins/field.py

@@ -0,0 +1,74 @@
+from enum import auto
+from typing import Any, Dict, Optional
+
+from rest_framework.fields import Field
+
+from dynamicforms.mixins.field_render import FieldRenderMixin
+
+from .base import ViewModeBase
+from .render_mode_enum import ViewModeEnum
+
+
+class ViewModeField(ViewModeBase):
+    """
+    Binds the field definition from serializer to data for rendering
+    """
+
+    bound_value = None
+    bound_value_row = None
+
+    class ViewMode(ViewModeEnum):
+        FORM = auto()  # Render to form field
+        TABLE_DATA = auto()  # Render to table td
+        TABLE_HEADER = auto()  # Render field label to table th
+
+    def __init__(
+        self,
+        view_mode: "ViewModeField.ViewMode",
+        field: FieldRenderMixin,
+        value: Optional[Any] = None,
+        value_row: Optional[Dict[Any, Any]] = None,
+    ):
+        """
+        Will patch the field instance such that it will get this mixin mixed in.
+        Optionally row and field values can also be provided for a one-off rendering
+
+        :param field: serializer field instance
+        :param value: field value in current data row
+        :param value_row: current data row value
+        """
+        field.__class__ = type("ViewModeBoundField", (ViewModeField, field.__class__), {})
+        self.set_bound_value(value, value_row)
+        super().__init__(view_mode)
+
+    def set_bound_value(self, value: Any, value_row: Dict[Any, Any]):
+        self.bound_value = value
+        self.bound_value_row = value_row
+
+    def render_form(self: "_ViewModeBoundField"):
+        """
+        renders field's serialized value to HTML. Currently code only for performance reasons, we might support
+        templating in the future
+
+        :return: rendered value for form view
+        """
+        return self.bound_value
+
+    def render_table(self: "_ViewModeBoundField"):
+        """
+        renders field's serialized value to HTML. Currently code only for performance reasons, we might support
+        templating in the future
+
+        :return: rendered value for table view
+        """
+        # TODO: Actually, the DRFTT.format_value() should be here and not in RenderMixin. Let's see if we can move it
+        return self.bound_value
+
+
+# noinspection PyAbstractClass
+class _ViewModeBoundField(ViewModeField, Field):
+    """
+    Dummy class just for type hinting
+    """
+
+    pass

dynamicforms/template_render/mixins/listserializer.py

@@ -0,0 +1,100 @@
+from enum import auto
+from typing import Dict, List
+
+from django.template import loader
+from rest_framework.reverse import reverse
+from rest_framework.serializers import ListSerializer
+
+from dynamicforms.mixins import FieldRenderMixin
+
+from .base import ViewModeBase
+from .render_mode_enum import ViewModeEnum
+from .util import convert_to_json_if
+
+
+class ViewModeListSerializer(ViewModeBase, FieldRenderMixin, ListSerializer):
+    bound_value = None
+
+    class ViewMode(ViewModeEnum):
+        TABLE = auto()  # Render to full table with header, filter, rows
+
+    def __init__(self, *args, **kwargs):
+        self.child = None
+        kwargs.setdefault("display_table", kwargs["child"].display_table)
+        kwargs.setdefault("display_form", kwargs["child"].display_form)
+        super().__init__(*args, **kwargs)
+
+    def set_bound_value(self, value: List[Dict]):
+        self.bound_value = value
+
+    def render_table(self: "_ViewModeBoundListSerializer"):
+        template = loader.get_template("template_render/full_table.html")
+        context = dict(serializer=self, columns=self.render_fields)
+        return template.render(context)
+
+    @property
+    def render_fields(self: "_ViewModeBoundListSerializer"):
+        return self.child.render_fields
+
+    @property
+    def render_actions(self: "_ViewModeBoundListSerializer"):
+        return self.child.render_actions
+
+    def component_params(self: "_ViewModeBoundListSerializer", output_json: bool = True, data=None):
+        res = self.child.component_params(output_json=False)
+
+        if self.paginator:
+            res["rows"] = data or self.paginator.get_paginated_response(self.data).data
+        else:
+            res["rows"] = dict(prev=None, next=None, results=data or self.data)
+
+        res["list_url"] = self.reverse_url
+        return convert_to_json_if(res, output_json)
+
+    # propagate original serializer's uuid to list serializer
+    uuid = property(lambda self: self.child.uuid, lambda self, value: setattr(self.child, "uuid", value))
+
+    @classmethod
+    def get_reverse_url(cls, view_name, request):
+        return reverse(view_name + "-list", format="json", request=request)
+
+    def apply_component_context(self, request=None, paginator=None):
+        # Different to ViewModeSerializer.get_component_context - which is a class method creating the instances
+        # this one will decorate existing instance with the appropriate values needed for rendering
+        # in all other respects, they are the same
+        request = request or self.request
+        paginator = paginator or self.context.get("view", type("NoView", (object,), dict(paginator=None))).paginator
+
+        self.child.apply_component_context(request, paginator)
+        self.view_mode = ViewModeListSerializer.ViewMode.TABLE
+        self.reverse_url = self.get_reverse_url(self.child.template_context["url_reverse"], request)
+        self.paginator = paginator
+        if paginator:
+            base_url = paginator.base_url.split("?", 1)
+            paginator.base_url = self.reverse_url + (("?" + base_url[1]) if len(base_url) == 2 else "")
+
+    @property
+    def request(self: "_ViewModeBoundListSerializer"):
+        if self.context and "view" in self.context and self.context["view"].request:
+            return self.context["view"].request
+        elif self.child:
+            return self.child.request
+        return None
+
+    def as_component_def(self: "DFField") -> dict:  # noqa
+        if hasattr(self.child, "as_component_def_table"):
+            return self.child.as_component_def_table
+        res = super().as_component_def()
+        res["render_params"]["form_component_name"] = "DList"
+        self.child.apply_component_context()
+        res["render_params"]["form_component_def"] = self.child.component_params(output_json=False)
+        return res
+
+
+# noinspection PyAbstractClass
+class _ViewModeBoundListSerializer(ViewModeListSerializer, ListSerializer):
+    """
+    Dummy class just for type hinting
+    """
+
+    pass

dynamicforms/template_render/mixins/render_mode_enum.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ViewModeEnum(Enum):
+    # noinspection PyMethodParameters
+    def _generate_next_value_(name, start, count, last_values):
+        # We use this construct to obtain value same as name
+        return name