wbcore 1.59.9__py2.py3-none-any.whl

wbcore/metadata/configs/display/instance_display/styles.py

@@ -0,0 +1,42 @@
+class Style:
+    """A convinience class to have all styles and helper methods contained in one place.
+
+    Static CSS Variables may be used as classmembers, e.g.: `Style.MIN_CONTENT` or `Style.AUTO`
+    Dynamic CSS Variables, such as specific sizes, may be used as static methods, e.g.: `Style.fr(5)`
+    """
+
+    MIN_CONTENT = "min-content"
+    MAX_CONTENT = "max-content"
+    AUTO = "auto"
+
+    @staticmethod
+    def fr(fractions: int) -> str:
+        return Style._stringify(fractions, "fr")
+
+    @staticmethod
+    def px(pixels: int) -> str:
+        return Style._stringify(pixels, "px")
+
+    @staticmethod
+    def pct(percent: float) -> str:
+        return Style._stringify(percent, "%")
+
+    @staticmethod
+    def rem(rem: float) -> str:
+        return Style._stringify(rem, "rem")
+
+    @staticmethod
+    def vh(vh: int) -> str:
+        return Style._stringify(vh, "vh")
+
+    @staticmethod
+    def vw(vw: int) -> str:
+        return Style._stringify(vw, "vw")
+
+    @staticmethod
+    def _stringify(value: int | float, unit: str) -> str:
+        return f"{value}{unit}"
+
+    @staticmethod
+    def minmax(min_value: str, max_value: str) -> str:
+        return f"minmax({min_value}, {max_value})"

wbcore/metadata/configs/display/instance_display/utils.py

@@ -0,0 +1,74 @@
+from django.utils.translation import gettext
+
+
+def repeat(n: int, unit: str) -> str:
+    """Creates a CSS repeat element, that makes the `unit` be repeated `n` times.
+
+    Example:
+        `repeat(5, Style.px(20))` results in the string `'repeat(5, 20px)'`
+
+    Attributes:
+        n (int): The amount of times the unit should be repeated
+        unit (str): The unit that is going to be repeated. Should be generated by the unit helper methods, e.g. `Style.px(20)`
+
+    Returns:
+        A valid css string containing the information about repeated an element `n` times.
+    """
+
+    return f"repeat({n}, {unit})"
+
+
+def repeat_field(n: int, field_name: str) -> str:
+    """Creates a string repeating the `field_name` `n` times
+
+    Example:
+        `repeat_field(5, Style.px(20))` results in the string `'20px 20px 20px 20px 20px'`
+
+    Args:
+        n: An integer specifying how often the the `field_name` should be repeated
+        field_name: A string, which should be repeated `n` times
+
+    Returns:
+        A string where the value of `field_name` is duplicated `n` times
+    """
+    return " ".join([field_name] * n)
+
+
+def grid_definition(*units: str) -> str:
+    """Concatanates the arguments specified as positional arguments with a space to create a valid css string to define a grid
+
+    Arguments:
+        *units: Positional string arguments that will be concatanated
+
+    Returns:
+        A valid css string of space seperated strings
+
+    """
+    return " ".join(units)
+
+
+def split_list_into_grid_template_area_sublists(elem_list: list, column_number: int) -> list[list]:
+    """Splits a list of elements into sublists of the provided column number length and adds empty grid cells at the end if necessary
+
+    Args:
+        elem_list (list): List of elements to split
+        column_number (int): Number of columns in the grid. Must be above 0
+
+    Returns:
+        list: A list of lists of exactly the specified length
+
+    Raises:
+        ValueError: If column_number below 1 is provided
+    """
+
+    if column_number < 1:
+        raise ValueError(gettext("Column number has to be at least 1!"))
+
+    sublists = [elem_list]
+    if column_number <= len(elem_list):
+        # If we don't have enough elements in the list to split into the target column number we avoid the IndexError and instead populate the sublist with empty fields
+        sublists = [elem_list[x : x + column_number] for x in range(0, len(elem_list), column_number)]
+
+    for _ in range(column_number - len(sublists[-1])):
+        sublists[-1].append(".")
+    return sublists

wbcore/metadata/configs/display/list_display.py

@@ -0,0 +1,290 @@
+from dataclasses import dataclass, field
+from typing import Iterable, Literal, Optional
+
+from slugify import slugify
+
+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 | None
+    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
+
+    lock_position: Literal["left"] | Literal["right"] | None = None
+    movable: bool = True
+    resizable: bool = True
+    suppress_auto_size: bool = False
+    auto_size: bool = False
+    menu: bool = True
+    size_to_fit: bool = True
+
+    def __post_init__(self):
+        self.identifier = (
+            self.key if self.key else slugify(str(self.label))
+        )  # we cast to str explicitly in case label is in a translation wrapper
+
+    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 serialize(self, parent_identifier: str | None = None):
+        identifier = parent_identifier + "_" + self.identifier if parent_identifier else self.identifier
+        repr = {
+            "identifier": identifier,
+            "key": self.key,
+            "label": self.label,
+            "formatting_rules": [dict(rule) for rule in self.formatting_rules],
+        }
+
+        if self.width:
+            repr["width"] = self.width
+
+        if self.hide:
+            repr["hide"] = self.hide
+
+        if self.pinned and self.pinned in ["left", "right"]:
+            repr["pinned"] = self.pinned
+
+        if self.children:
+            repr["children"] = [child.serialize(identifier) for child in self.children]
+            repr["marry_children"] = self.marry_children is True  # Convert None into False
+
+        if self.show:
+            repr["show"] = self.show
+
+        if self.open_by_default is not None:
+            repr["open_by_default"] = self.open_by_default
+
+        if not self.movable:
+            repr["movable"] = self.movable
+
+        if not self.resizable:
+            repr["resizable"] = self.resizable
+
+        if self.lock_position:
+            repr["lock_position"] = self.lock_position
+
+        if self.suppress_auto_size:
+            repr["suppress_auto_size"] = self.suppress_auto_size
+
+        if self.auto_size:
+            repr["auto_size"] = self.auto_size
+
+        if not self.menu:
+            repr["menu"] = self.menu
+
+        if not self.size_to_fit:
+            repr["size_to_fit"] = self.size_to_fit
+
+        if self.tooltip:
+            repr["tooltip"] = self.tooltip.serialize()
+        return repr
+
+
+@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 and not all([item.value is not None for item in self.items]):
+            raise ValueError("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, kw_only=True)
+class BaseTreeGroupLevelOption:
+    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 | None = 1  # None would actually return all group keys concatenated.
+
+    def __iter__(self):
+        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
+
+
+@dataclass(unsafe_hash=True, kw_only=True)
+class TreeGroupLevelOption(BaseTreeGroupLevelOption):
+    list_endpoint: str
+    reorder_endpoint: str | None = None
+    reparent_endpoint: str | None = None
+    parent_field: str = "parent"
+    ordering_field: str = "order"
+
+    def __iter__(self):
+        yield from super().__iter__()
+        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 "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"
+    condensed: bool = False
+
+    auto_height: bool = False
+    auto_size_columns: bool = False
+
+    tree: bool = False
+    tree_group_parent_pointer: str | None = (
+        None  # if specified, the display assumes the whole tree data is given in the initial request and that it can be grouped by the given group key
+    )
+    tree_group_key: str = "_group_key"  # The field the `tree_group_parent_pointer` points to
+
+    tree_group_field: 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]:
+        if self.fields:  # fields can be None
+            for f in filter(lambda o: o, self.fields):  # field can be None
+                yield from f.iterate_leaf_fields()
+
+    def __iter__(self):
+        yield "editable", self.editable
+        yield "fields", [field.serialize() 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
+
+        yield "auto_height", self.auto_height
+        yield "auto_size_columns", self.auto_size_columns
+
+        if self.condensed:
+            yield "condensed", self.condensed
+
+        if self.tree:
+            yield "tree", self.tree
+            tree_group = {
+                "field": (self.tree_group_field if self.tree_group_field else self.fields[0].key),
+                "open_level": self.tree_group_open_level,
+                "field_sortable": self.tree_group_field_sortable,
+                "group_key": self.tree_group_key,
+                "parent_pointer": self.tree_group_parent_pointer,
+            }
+            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,26 @@
+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)
+
+    def __str__(self) -> str:
+        return f"{self.title} - {self.user} ({self.display_identifier})"
+
+
+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)
+
+    def __str__(self) -> str:
+        return f"{self.display_identifier_path} ({self.user})"

wbcore/metadata/configs/display/view_config.py

@@ -0,0 +1,85 @@
+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()
+
+        display_identifier_path = self.view.display_identifier_config_class(
+            self.view, self.request, self.instance
+        ).display_identifier_path()
+
+        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 display_identifier_path(self) -> str:
+        display = self.view.display_config_class
+        slugified_display_module = slugify(display.__module__.replace(".", "-"))
+        slugified_display_class = slugify(display.__name__)
+        display_identifier_path = f"{slugified_display_module}-{slugified_display_class}"
+
+        # 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.
+        if inline_path := self.request.META.get("HTTP_WB_DISPLAY_IDENTIFIER", None):
+            display_identifier_path = f"{inline_path}.{display_identifier_path}"
+        return display_identifier_path
+
+    def get_metadata(self):
+        return self.display_identifier_path()

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