wbcore 2.2.1__py2.py3-none-any.whl

wbcore/metadata/configs/display/list_display.py

@@ -0,0 +1,230 @@
+from dataclasses import dataclass, field
+from typing import Iterable, Literal, Optional
+
+from wbcore.metadata.configs.display.formatting import Formatting, FormattingRule
+
+
+@dataclass
+class Tooltip:
+    key: str | None = None
+    endpoint: str | None = None
+    width: str | None = None
+    height: str | None = None
+
+    def __post_init__(self):
+        if not self.key and not self.endpoint:
+            raise ValueError("Either key or endpoint needs to be specified.")
+
+    def serialize(self):
+        tooltip = {}
+        if self.key:
+            tooltip["key"] = self.key
+
+        if self.endpoint:
+            tooltip["endpoint"] = self.endpoint
+
+        if self.width:
+            tooltip["width"] = self.width
+
+        if self.height:
+            tooltip["height"] = self.height
+
+        return tooltip
+
+
+@dataclass(unsafe_hash=True)
+class Field:
+    key: str
+    label: str
+    formatting_rules: Iterable[FormattingRule] = field(default_factory=list)
+    width: int | None = None
+
+    tooltip: Tooltip | None = None
+
+    hide: bool | None = None
+    pinned: str | None = None
+
+    children: list["Field"] | None = None
+    marry_children: bool | None = True
+    show: Literal["open"] | Literal["closed"] | None = None
+    open_by_default: bool | None = None
+    supress_movable: bool = False
+    lock_position: bool = False
+    resizable: bool = True
+
+    def iterate_leaf_fields(self, aggregated_parent_label: str = ""):
+        label = self.label
+        if aggregated_parent_label:
+            label = aggregated_parent_label + " " + label
+        if self.children:
+            for children in self.children:
+                yield from children.iterate_leaf_fields(label)
+        else:
+            yield self.key, label
+
+    def __iter__(self):
+        yield "key", self.key
+        yield "label", self.label
+        yield "formatting_rules", [dict(rule) for rule in self.formatting_rules]
+
+        if self.width:
+            yield "width", self.width
+
+        if self.hide:
+            yield "hide", self.hide
+
+        if self.pinned and self.pinned in ["left", "right"]:
+            yield "pinned", self.pinned
+
+        if self.children:
+            yield "children", [dict(child) for child in self.children]
+            yield "marry_children", self.marry_children is True  # Convert None into False
+
+        if self.show:
+            yield "show", self.show
+
+        if self.open_by_default is not None:
+            yield "open_by_default", self.open_by_default
+        yield "supress_movable", self.supress_movable
+        yield "lock_position", self.lock_position
+
+        if self.tooltip:
+            yield "tooltip", self.tooltip.serialize()
+
+
+@dataclass(unsafe_hash=True)
+class LegendItem:
+    icon: str
+    label: str
+    value: Optional[str | bool] = None
+
+    def __iter__(self):
+        yield "icon", self.icon
+        yield "label", self.label
+
+        if self.value is not None:
+            yield "value", self.value
+
+
+@dataclass(unsafe_hash=True)
+class Legend:
+    items: list[LegendItem]
+    label: str | None = None
+    key: str | None = None
+
+    def __post_init__(self):
+        if self.key:
+            assert all(
+                [item.value is not None for item in self.items]
+            ), "If key is set, all items need to specify a value."
+
+    def __iter__(self):
+        if self.label:
+            yield "label", self.label
+
+        if self.key:
+            yield "key", self.key
+
+        yield "items", [dict(item) for item in self.items]
+
+
+@dataclass(unsafe_hash=True)
+class TreeGroupLevelOption:
+    list_endpoint: str
+    reorder_endpoint: str | None = None
+    reparent_endpoint: str | None = None
+    lookup: str = "_group_key"
+    filter_key: str = "group_keys"
+    filter_whitelist: list[str] = field(default_factory=list)
+    filter_blacklist: list[str] = field(default_factory=list)
+    clear_filter: bool = (
+        False
+        # Set to True if preselected filters other than required ones need to be cleared out before fetching the tree group
+    )
+    filter_depth: int = 1
+    parent_field: str = "parent"
+    ordering_field: str = "order"
+
+    def __iter__(self):
+        endpoints = {"list": self.list_endpoint}
+        if self.reorder_endpoint:
+            endpoints["reorder"] = self.reorder_endpoint
+
+        if self.reparent_endpoint:
+            endpoints["reparent"] = self.reparent_endpoint
+
+        yield "endpoints", endpoints
+        yield "lookup", self.lookup
+        yield "filter_key", self.filter_key
+        yield "filter_whitelist", self.filter_whitelist
+        yield "filter_blacklist", self.filter_blacklist
+        yield "clear_filter", self.clear_filter
+        yield "filter_depth", self.filter_depth
+        yield "parent_field", self.parent_field
+        yield "ordering_field", self.ordering_field
+
+
+@dataclass(unsafe_hash=True)
+class ListDisplay:
+    fields: list[Field | None]
+    legends: list[Legend] = field(default_factory=list)
+    formatting: list[Formatting] = field(default_factory=list)
+    editable: bool = True
+    hide_control_bar: bool = False
+
+    ordering_field: str = "order"
+
+    tree: bool = False
+    tree_group_pinned: str = "left"
+    tree_group_field: str | None = None
+    tree_group_label: str | None = None
+    tree_group_open_level: int = 0
+    tree_group_field_sortable: bool = False
+
+    tree_group_level_options: list[TreeGroupLevelOption] = field(default_factory=list)
+
+    @property
+    def flatten_fields(self) -> tuple[str, str]:
+        for f in self.fields:
+            yield from f.iterate_leaf_fields()
+
+    def __iter__(self):
+        yield "editable", self.editable
+        yield "fields", [dict(field) for field in self.fields if field]
+        yield "legends", [dict(legend) for legend in self.legends if legend]
+        yield "formatting", [dict(formatting) for formatting in self.formatting if formatting]
+        yield "hide_control_bar", self.hide_control_bar
+        yield "ordering_field", self.ordering_field
+        if self.tree:
+            yield "tree", self.tree
+            tree_group = {
+                "pinned": self.tree_group_pinned,
+                "field": self.tree_group_field if self.tree_group_field else self.fields[0].key,
+                "label": self.tree_group_label if self.tree_group_label else self.fields[0].key,
+                "open_level": self.tree_group_open_level,
+                "field_sortable": self.tree_group_field_sortable,
+            }
+            tree_group["level_options"] = [dict(level_option) for level_option in self.tree_group_level_options]
+            yield "tree_group", tree_group
+
+
+@dataclass(unsafe_hash=True)
+class Calendar:
+    title: str
+    period: str
+    all_day: bool
+    color: str
+    icon: str
+    entities: list
+    endpoint: str
+
+    def __iter__(self):
+        yield "calendar", {
+            "title": self.title,
+            "period": self.period,
+            "all_day": self.all_day,
+            "color": self.color,
+            "icon": self.icon,
+            "entities": self.entities,
+            "endpoint": self.endpoint,
+        }

wbcore/metadata/configs/display/models.py

@@ -0,0 +1,20 @@
+from django.contrib.auth import get_user_model
+from django.db import models
+
+
+class Preset(models.Model):
+    title = models.CharField(max_length=64)
+    user = models.ForeignKey(
+        to=get_user_model(), related_name="presets", on_delete=models.CASCADE, null=True, blank=True
+    )
+    display_identifier = models.CharField(max_length=512)
+    display = models.JSONField(null=True, blank=True)
+
+
+class AppliedPreset(models.Model):
+    user = models.ForeignKey(to=get_user_model(), related_name="applied_presets", on_delete=models.CASCADE)
+    display_identifier_path = models.CharField(max_length=1024)
+    preset = models.ForeignKey(
+        to=Preset, related_name="applied_presets", on_delete=models.SET_NULL, null=True, blank=True
+    )
+    display = models.JSONField(null=True, blank=True)

wbcore/metadata/configs/display/view_config.py

@@ -0,0 +1,82 @@
+from contextlib import suppress
+
+from django.utils.text import slugify
+from rest_framework.request import Request
+from rest_framework.views import View
+from wbcore.metadata.configs.display.instance_display.display import Display
+from wbcore.metadata.configs.display.list_display import ListDisplay
+from wbcore.metadata.configs.display.windows import Window
+
+from ..base import WBCoreViewConfig
+from .models import AppliedPreset
+
+
+class DisplayViewConfig(WBCoreViewConfig):
+    metadata_key = "display"
+    config_class_attribute = "display_config_class"
+
+    def __init__(self, view: View, request: Request, instance: bool | None = None):
+        self.tooltip = request.GET.get("tooltip", None) == "true"
+        self.inline = request.GET.get("inline", None) == "true"
+        super().__init__(view, request, instance)
+
+    def get_window(self) -> Window | None:
+        return None
+
+    def get_instance_display(self) -> Display | None:
+        return None
+
+    def get_list_display(self) -> ListDisplay | None:
+        return None
+
+    def get_preview_display(self) -> Display | None:
+        return None
+
+    def get_metadata(self) -> dict:
+        display = dict()
+        instance_display = self.get_instance_display()
+        if isinstance(instance_display, Display):
+            display["instance"] = instance_display.serialize(view_config=self, view=self.view, request=self.request)
+        elif instance_display:
+            display["instance"] = list(instance_display)
+        else:
+            display["instance"] = Display(pages=[]).serialize()
+
+        if not self.instance:
+            list_display = self.get_list_display()
+            if isinstance(list_display, Display):
+                display["list"] = list_display.serialize()
+            else:
+                display["list"] = dict(list_display or {})
+
+        if window := self.get_window():
+            display["window"] = window.serialize()
+
+        # We get the path from the header (if it exists, only for nested tables inside forms) and then join it
+        # with the current display identifier. If there is an applied preset for this user - we return it.
+        path = self.request.META.get("HTTP_WB_DISPLAY_IDENTIFIER", None)
+        display_identifier = self.view.display_identifier_config_class(
+            self.view, self.request, self.instance
+        ).get_display_identifier()
+        display_identifier_path = ".".join(filter(lambda element: element is not None, [path, display_identifier]))
+
+        with suppress(AppliedPreset.DoesNotExist):
+            display["preset"] = AppliedPreset.objects.get(
+                user=self.request.user, display_identifier_path=display_identifier_path
+            ).display
+
+        return display
+
+
+class DisplayIdentifierViewConfig(WBCoreViewConfig):
+    metadata_key = "display_identifier"
+    config_class_attribute = "display_identifier_config_class"
+
+    def get_display_identifier(self) -> str:
+        display = self.view.display_config_class
+        slugified_display_module = slugify(display.__module__.replace(".", "-"))
+        slugified_display_class = slugify(display.__name__)
+        return f"{slugified_display_module}-{slugified_display_class}"
+
+    def get_metadata(self):
+        return self.get_display_identifier()

wbcore/metadata/configs/display/views.py

@@ -0,0 +1,48 @@
+from django.shortcuts import get_object_or_404
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.status import HTTP_200_OK, HTTP_201_CREATED, HTTP_204_NO_CONTENT
+from rest_framework.views import APIView
+
+from .models import AppliedPreset
+
+
+class PresetAPIView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request: Request, display_identifier_path: str) -> Response:
+        preset = get_object_or_404(
+            AppliedPreset,
+            display_identifier_path=display_identifier_path,
+            user=request.user,
+        )
+
+        return Response(preset.display, status=HTTP_200_OK)
+
+    def delete(self, request: Request, display_identifier_path: str) -> Response:
+        preset = get_object_or_404(
+            AppliedPreset,
+            display_identifier_path=display_identifier_path,
+            user=request.user,
+        )
+
+        preset.delete()
+
+        return Response(status=HTTP_204_NO_CONTENT)
+
+    def post(self, request: Request, display_identifier_path: str) -> Response:
+        defaults = {}
+
+        if display := self.request.data.get("display", None):
+            defaults["display"] = display
+
+        if preset := self.request.data.get("preset", None):
+            defaults["preset"] = preset
+
+        AppliedPreset.objects.update_or_create(
+            user=request.user,
+            display_identifier_path=display_identifier_path,
+            defaults=defaults,
+        )
+        return Response(status=HTTP_201_CREATED)

wbcore/metadata/configs/display/windows.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Window:
+    """A window that can specify the minimum and maximum width and height of a window"""
+
+    min_width: int | None = None
+    max_width: int | None = None
+    min_height: int | None = None
+    max_height: int | None = None
+
+    def serialize(self) -> dict[str, int]:
+        window = {}
+
+        if self.min_width:
+            window["min_width"] = self.min_width
+
+        if self.max_width:
+            window["max_width"] = self.max_width
+
+        if self.min_height:
+            window["min_height"] = self.min_height
+
+        if self.max_height:
+            window["max_height"] = self.max_height
+
+        return window

wbcore/metadata/configs/documentations.py

@@ -0,0 +1,11 @@
+from .base import WBCoreViewConfig
+
+
+class DocumentationViewConfig(WBCoreViewConfig):
+    metadata_key = "documentation"
+    config_class_attribute = "documentation_config_class"
+
+    def get_metadata(self) -> str | None:
+        if url := self.view._get_documentation_url(self.instance):  # type: ignore
+            return url
+        return None

wbcore/metadata/configs/endpoints.py

@@ -0,0 +1,176 @@
+import re
+
+from rest_framework.reverse import reverse
+from wbcore.enums import WidgetType
+from wbcore.utils.urls import get_parse_endpoint, get_urlencode_endpoint
+
+from .base import WBCoreViewConfig
+
+
+class EndpointViewConfig(WBCoreViewConfig):
+    metadata_key = "endpoints"
+    config_class_attribute = "endpoint_config_class"
+
+    PK_FIELD = "id"
+    DELETE_PK_FIELD = "id"
+    UPDATE_PK_FIELD = "id"
+
+    def get_endpoint(self, **kwargs):
+        model = self.view.get_model()
+        basename_method_name = (
+            "get_representation_endpoint"
+            if self.view.WIDGET_TYPE == WidgetType.SELECT.value
+            else "get_endpoint_basename"
+        )
+
+        if model and (basename_method := getattr(model, basename_method_name, None)):
+            basename = basename_method().replace(
+                "-list", ""
+            )  # we replace "-list" in case it's a representation endpoint which historically comes with the sufix "-list"
+            is_list = kwargs.get("is_list", False)
+            if self.instance and not is_list:
+                return reverse(f"{basename}-detail", args=[self.view.kwargs.get("pk")], request=self.request)
+            else:
+                return reverse(f"{basename}-list", request=self.request)
+        return None
+
+    def get_instance_endpoint(self, **kwargs):
+        return self.get_endpoint()
+
+    def _get_instance_endpoint(self):
+        if endpoint := self.get_instance_endpoint():
+            from wbcore.viewsets import ViewSet
+
+            content_type = self.view.get_content_type()
+            if content_type:
+                change_permission = f"{content_type.app_label}.view_{content_type.model}"
+                permission = self.request.user.has_perm(change_permission)
+            elif isinstance(self.view, ViewSet):
+                permission = True
+            if permission:
+                if self.instance:
+                    if not re.search(r"\/\d+\/$", endpoint) and (pk := self.view.kwargs.get("pk", None)):
+                        endpoint += str(pk) + "/"
+                else:
+                    endpoint += "{{" + self.PK_FIELD + "}}/"
+                return endpoint
+        return None
+
+    def get_list_endpoint(self, **kwargs):
+        return self.get_endpoint(is_list=True)
+
+    def _get_list_endpoint(self):
+        return self.get_list_endpoint()
+
+    def get_delete_endpoint(self, **kwargs):
+        return self.get_endpoint()
+
+    def _get_delete_endpoint(self, **kwargs):
+        read_only = getattr(self.view, "READ_ONLY", False)
+        content_type = self.view.get_content_type()
+
+        if content_type is None:
+            return None
+
+        delete_permission = f"{content_type.app_label}.delete_{content_type.model}"
+
+        if read_only or not self.request.user.has_perm(delete_permission):
+            return None
+        if endpoint := self.get_delete_endpoint():
+            if self.instance:
+                if not re.search(r"\/\d+\/$", endpoint) and (pk := self.view.kwargs.get("pk", None)):
+                    return f"{endpoint}{pk}/"
+                return endpoint
+            else:
+                return endpoint + "{{" + self.DELETE_PK_FIELD + "}}/"
+        return None
+
+    def get_create_endpoint(self, **kwargs):
+        return self.get_endpoint(is_list=True)
+
+    def _get_create_endpoint(self):
+        from wbcore.viewsets import ViewSet
+
+        read_only = getattr(self.view, "READ_ONLY", False)
+        if read_only:
+            return None
+
+        if endpoint := self.get_create_endpoint():
+            content_type = self.view.get_content_type()
+            if content_type:
+                create_permission = f"{content_type.app_label}.add_{content_type.model}"
+                permission = self.request.user.has_perm(create_permission)
+            elif isinstance(self.view, ViewSet):
+                permission = True
+            if permission:
+                endpoint, query_params = get_parse_endpoint(endpoint)
+                query_params["new_mode"] = "true"
+                return get_urlencode_endpoint(endpoint, query_params)
+
+        return None
+
+    def get_update_endpoint(self, **kwargs):
+        return self.get_instance_endpoint()
+
+    def _get_update_endpoint(self):
+        if (endpoint := self.get_update_endpoint()) and not getattr(self.view, "READ_ONLY", False):
+            from wbcore.viewsets import ViewSet
+
+            content_type = self.view.get_content_type()
+            if content_type:
+                change_permission = f"{content_type.app_label}.change_{content_type.model}"
+                permission = self.request.user.has_perm(change_permission)
+            elif isinstance(self.view, ViewSet):
+                permission = True
+            if permission:
+                if self.instance:
+                    if not re.search(r"\/\d+\/$", endpoint) and (pk := self.view.kwargs.get("pk", None)):
+                        endpoint += str(pk) + "/"
+                else:
+                    endpoint += "{{" + self.UPDATE_PK_FIELD + "}}/"
+                return endpoint
+        return None
+
+    def get_reorder_endpoint(self, **kwargs):
+        return self._get_update_endpoint()
+
+    def _get_reorder_endpoint(self):
+        if (endpoint := self.get_reorder_endpoint()) and hasattr(self.view, "reorder"):
+            return endpoint + "reorder/"
+
+    def get_pre_change_endpoint(self, pk):
+        return None
+
+    def _get_pre_change_endpoint(self):
+        if (pk := self.view.kwargs.get("pk", None)) and (endpoint := self.get_pre_change_endpoint(pk)):
+            return endpoint
+        return None
+
+    def get_pre_create_endpoint(self, pk):
+        return None
+
+    def _get_pre_create_endpoint(self):
+        if (pk := self.view.kwargs.get("pk", None)) and (endpoint := self.get_pre_create_endpoint(pk)):
+            return endpoint
+        return None
+
+    def get_pre_delete_endpoint(self, pk):
+        return None
+
+    def _get_pre_delete_endpoint(self):
+        if (pk := self.view.kwargs.get("pk", None)) and (endpoint := self.get_pre_delete_endpoint(pk)):
+            return endpoint
+        return None
+
+    def get_metadata(self) -> dict:
+        return {
+            "instance": self._get_instance_endpoint(),
+            "list": self._get_list_endpoint(),
+            "delete": self._get_delete_endpoint(),
+            "create": self._get_create_endpoint(),
+            "update": self._get_update_endpoint(),
+            "reorder": self._get_reorder_endpoint(),
+            "pre_change": self._get_pre_change_endpoint(),
+            "pre_create": self._get_pre_create_endpoint(),
+            "pre_delete": self._get_pre_delete_endpoint(),
+        }

wbcore/metadata/configs/fields.py

@@ -0,0 +1,17 @@
+from collections import defaultdict
+
+from .base import WBCoreViewConfig
+
+
+class FieldsViewConfig(WBCoreViewConfig):
+    metadata_key = "fields"
+    config_class_attribute = "fields_config_class"
+
+    def get_metadata(self) -> dict:
+        fields = defaultdict(dict)
+        if (serializer_class := getattr(self.view, "get_serializer", None)) and (serializer := serializer_class()):
+            for field_name, field in serializer.fields.items():
+                field_key, field_representation = field.get_representation(self.request, field_name)
+                fields[field_key].update(field_representation)
+
+        return fields

wbcore/metadata/configs/filter_fields.py

@@ -0,0 +1,42 @@
+from contextlib import suppress
+
+from wbcore.filters import DjangoFilterBackend
+
+from .base import WBCoreViewConfig
+
+
+class FilterFieldsViewConfig(WBCoreViewConfig):
+    metadata_key = "filter_fields"
+    config_class_attribute = "filter_fields_config_class"
+
+    def get_metadata(self):
+        filter_fields = dict()
+
+        with suppress(StopIteration):
+            backend = next(
+                filter(lambda b: issubclass(b, DjangoFilterBackend), getattr(self.view, "filter_backends", []))
+            )
+            if filterset_class := backend().get_filterset_class(self.view, self.view.queryset):  # type: ignore
+                filterset = filterset_class()
+                filters = filterset.get_filters()
+                hidden_fields = []
+                # TODO: This should be the responsibility of the filterset_class to return also the df_fields
+                if filterset_class_meta := getattr(filterset_class, "Meta", None):
+                    hidden_fields.extend(getattr(filterset_class_meta, "hidden_fields", []))
+                    filters.update(getattr(filterset_class_meta, "df_fields", {}))
+                for name, field in filters.items():
+                    field.parent = filterset
+                    if (
+                        not field.hidden
+                        and name not in hidden_fields
+                        and (res := field.get_representation(self.request, name, self.view))
+                    ):
+                        representation, lookup_expr = res
+                        if field.key in filter_fields:
+                            filter_fields[field.key]["lookup_expr"].append(lookup_expr)
+                        else:
+                            filter_fields[field.key] = representation
+                            filter_fields[field.key]["lookup_expr"] = [lookup_expr]
+                            filter_fields[field.key]["label"] = field.label
+
+        return filter_fields

wbcore/metadata/configs/identifiers.py

@@ -0,0 +1,25 @@
+from .base import WBCoreViewConfig
+
+
+class IdentifierViewConfig(WBCoreViewConfig):
+    metadata_key = "identifier"
+    config_class_attribute = "identifier_config_class"
+
+    # TODO: This does not yet work on the frontend, but should
+    def get_metadata(self) -> str | None:
+        if identifier := getattr(self.view, "IDENTIFIER", None):
+            return identifier
+
+        content_type = self.view.get_content_type()  # type: ignore
+        identifier = f"{content_type.app_label}:{content_type.model}"
+
+        return identifier
+
+
+class DependantIdentifierViewConfig(WBCoreViewConfig):
+    metadata_key = "dependant_identifier"
+    config_class_attribute = "dependant_identifier_config_class"
+
+    # TODO: This should return a list, shouldn't it?
+    def get_metadata(self) -> str | None:
+        return getattr(self.view, "DEPENDANT_IDENTIFIER", None)