wbcore 2.2.1__py2.py3-none-any.whl

wbcore/metadata/configs/buttons/buttons.py

@@ -0,0 +1,142 @@
+from dataclasses import dataclass, field
+from typing import Iterable, Optional
+
+from django.utils.translation import gettext as _
+from django.utils.translation import gettext_lazy
+from rest_framework.request import Request
+from wbcore.enums import RequestType
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.serializers import ListSerializer, RepresentationSerializer, Serializer
+from wbcore.utils.urls import get_parse_endpoint, get_urlencode_endpoint
+
+from .bases import ButtonConfig, ButtonTypeMixin, ButtonUrlMixin
+from .enums import ButtonType, HyperlinkTarget
+
+
+@dataclass
+class DropDownButton(ButtonTypeMixin, ButtonConfig):
+    button_type = ButtonType.DROPDOWN
+    buttons: Iterable = field(default_factory=tuple)
+
+    def __post_init__(self):
+        if hasattr(super(), "__post_init__"):
+            super().__post_init__()
+        self.buttons = tuple(self.buttons)
+        assert isinstance(self.buttons, tuple)
+
+    def serialize(self, request, **kwargs):
+        res = super().serialize(request, **kwargs)
+        res["buttons"] = [
+            btn.serialize(request, **kwargs)
+            for btn in sorted(self.buttons, key=lambda e: (e.weight, e.label, e.title))
+        ]
+        return res
+
+    def __hash__(self):
+        return hash(self.title)
+
+
+@dataclass
+class WidgetButton(ButtonTypeMixin, ButtonUrlMixin, ButtonConfig):
+    button_type = ButtonType.WIDGET
+    new_mode: bool = False
+    open_new_by_default: bool | None = None
+
+    def serialize(self, request, **kwargs):
+        if self.new_mode and self.endpoint:
+            endpoint, params = get_parse_endpoint(self.endpoint)
+            params["new_mode"] = "true"
+            self.endpoint = get_urlencode_endpoint(endpoint, params)
+        res = super().serialize(request, **kwargs)
+        res["new_mode"] = self.new_mode
+
+        # When open by default is not set but it new mode is True
+        # then the default behaviour is to open the content in a new window
+        if self.open_new_by_default is not None:
+            res["open_new_by_default"] = self.open_new_by_default
+        elif self.new_mode:
+            res["open_new_by_default"] = True
+
+        return res
+
+    def __hash__(self):
+        if self.key:
+            return hash(self.key)
+        else:
+            return hash(self.endpoint)
+
+
+@dataclass
+class HyperlinkButton(ButtonTypeMixin, ButtonUrlMixin, ButtonConfig):
+    button_type = ButtonType.HYPERLINK
+    target: HyperlinkTarget = HyperlinkTarget.BLANK
+
+    def serialize(self, request, **kwargs):
+        res = super().serialize(request, **kwargs)
+        res["target"] = self.target.value
+        return res
+
+    def __hash__(self):
+        if self.key:
+            return hash(self.key)
+        else:
+            return hash(self.endpoint)
+
+
+@dataclass
+class ActionButton(ButtonTypeMixin, ButtonUrlMixin, ButtonConfig):
+    button_type = ButtonType.ACTION
+    method: RequestType = RequestType.POST
+    action_label: str = ""
+
+    description_fields: str = _("<p>Are you sure you want to proceed?</p>")
+    instance_display: Optional[Display] = None
+    serializer: Optional[type[Serializer]] = None
+    confirm_config: ButtonConfig = ButtonConfig(label=gettext_lazy("Confirm"), title=gettext_lazy("Confirm"))
+    cancel_config: ButtonConfig = ButtonConfig(
+        label=gettext_lazy("Cancel"),
+        title=gettext_lazy("Cancel"),
+    )
+
+    identifiers: Iterable[str] = field(default_factory=list)
+
+    def __hash__(self):
+        if self.key:
+            return hash(self.key)
+        else:
+            return hash(self.endpoint)
+
+    def __post_init__(self):
+        if hasattr(super(), "__post_init__"):
+            super().__post_init__()
+
+    def _get_fields(self, request: Request) -> dict:
+        fields = dict()
+        rs = RepresentationSerializer
+        ls = ListSerializer
+        if self.serializer and (field_items := self.serializer(context={"request": request}).fields.items()):
+            for name, _field in filter(lambda f: not isinstance(f[1], (rs, ls)), field_items):
+                field_name, representation = _field.get_representation(request, name)
+                fields[name] = representation
+
+            for name, _field in filter(lambda f: isinstance(f[1], (rs, ls)), field_items):
+                field_name, representation = _field.get_representation(request, name)
+                fields[representation["related_key"]].update(representation)
+                del fields[representation["related_key"]]["related_key"]
+
+        return fields
+
+    def serialize(self, request, **kwargs):
+        res = super().serialize(request, **kwargs)
+        res["action_label"] = self.action_label
+        res["method"] = self.method.value
+        res["description_fields"] = self.description_fields
+        res["confirm_config"] = self.confirm_config.serialize(request, **kwargs)
+        res["cancel_config"] = self.cancel_config.serialize(request, **kwargs)
+        res["identifiers"] = self.identifiers
+        if self.instance_display:
+            res["instance_display"] = self.instance_display.serialize()
+
+        if self.serializer:
+            res["fields"] = self._get_fields(request)
+        return res

wbcore/metadata/configs/buttons/enums.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+
+class ButtonDefaultColor(Enum):
+    SUCCESS = "success"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+    PRIMARY = "primary"
+    SECONDARY = "secondary"
+    INHERIT = "inherit"  # 'inherit' means that the button will take the color of a surrounding button group
+
+
+class ButtonType(Enum):
+    DROPDOWN = "dropdown"
+    HYPERLINK = "hyperlink"
+    WIDGET = "widget"
+    ACTION = "action"
+
+
+class HyperlinkTarget(Enum):
+    BLANK = "_blank"
+    SELF = "_self"
+    PARENT = "_parent"
+    TOP = "_top"

wbcore/metadata/configs/buttons/metadata.py

@@ -0,0 +1,8 @@
+from rest_framework.metadata import SimpleMetadata
+
+
+class ButtonMetadata(SimpleMetadata):
+    def generate_metadata(self, request, view):
+        if hasattr(super(), "generate_metadata"):
+            yield from super().generate_metadata(request, view)
+        yield "buttons", [btn.serialize(request=request) for btn in view.get_buttons(request)]

wbcore/metadata/configs/buttons/view_config.py

@@ -0,0 +1,176 @@
+from contextlib import suppress
+from typing import Generator
+
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import Button
+from wbcore.metadata.configs.buttons.buttons import DropDownButton
+from wbcore.signals.instance_buttons import (
+    add_button,
+    add_extra_button,
+    add_instance_button,
+)
+from wbcore.utils.importlib import parse_signal_received_for_module
+
+from ..base import WBCoreViewConfig
+
+
+class ButtonViewConfig(WBCoreViewConfig):
+    metadata_key = "buttons"
+    config_class_attribute = "button_config_class"
+
+    def serialize(self, base_buttons: set[Button], remote_resources):
+        """
+        Serialize the button view config
+
+        Args:
+            base_buttons: the base button gathered from the view config
+            remote_resources: the return of the send function
+        Returns:
+            Yield the serialized button, without duplicates and appends the module prefix to the remote button
+        """
+        base_buttons = list(zip([None] * len(base_buttons), base_buttons))  # append an empty perfix for base buttons
+        for prefix, btn in parse_signal_received_for_module(remote_resources):
+            base_buttons.append((prefix, btn))
+
+        keys = []
+        for key_prefix, btn in sorted(
+            filter(lambda x: x[1], base_buttons), key=lambda e: (e[1].weight, e[1].label, e[1].title)
+        ):
+            btn_serialized = btn.serialize(self.request, key_prefix=key_prefix)
+            if "key" not in btn_serialized or btn_serialized["key"] not in keys:  # ensure we don't include duplicates
+                yield btn_serialized
+
+    # Utils
+    def order_buttons(self, buttons: set, ordering: list):
+        yield from filter(lambda b: b in buttons, ordering)
+
+    # FSM Button Configuration
+    FSM_LIST = True
+    FSM_INSTANCE = True
+    FSM_DROPDOWN = False
+    FSM_DROPDOWN_ICON = WBIcon.ADD.icon
+    FSM_DROPDOWN_LABEL = "Transitions"
+    FSM_WEIGHT = 100
+
+    def get_fsm_buttons(self) -> set:
+        if self.FSM_DROPDOWN and (FSM_BUTTONS := getattr(self.view, "FSM_BUTTONS")) and len(FSM_BUTTONS) > 0:
+            return {
+                DropDownButton(
+                    label=self.FSM_DROPDOWN_LABEL,
+                    icon=self.FSM_DROPDOWN_ICON,
+                    title=self.FSM_DROPDOWN_LABEL,
+                    weight=self.FSM_WEIGHT,
+                    buttons=tuple(FSM_BUTTONS),
+                )
+            }
+        return getattr(self.view, "FSM_BUTTONS", set())
+
+    # list Button Configuration
+    LIST_BUTTONS = frozenset({Button.NEW.value, Button.REFRESH.value})
+    LIST_BUTTONS_ORDERING = [Button.NEW.value, Button.REFRESH.value]
+
+    def get_list_buttons(self) -> Generator[None, str, None]:
+        if content_type := self.view.get_content_type():
+            buttons = set(self.LIST_BUTTONS)
+            add_permission = f"{content_type.app_label}.add_{content_type.model}"
+
+            if not self.request.user.has_perm(add_permission):
+                with suppress(KeyError):
+                    buttons.remove(Button.NEW.value)
+
+            yield from self.order_buttons(buttons, self.LIST_BUTTONS_ORDERING)
+
+    # Instance Button Configuration
+    INSTANCE_BUTTONS = frozenset({Button.SAVE.value, Button.REFRESH.value, Button.DELETE.value})
+    INSTANCE_BUTTONS_ORDERING = [Button.SAVE.value, Button.REFRESH.value, Button.DELETE.value]
+
+    def get_instance_buttons(self) -> Generator[None, str, None]:
+        if content_type := self.view.get_content_type():
+            buttons = set(self.INSTANCE_BUTTONS)
+            change_permission = f"{content_type.app_label}.change_{content_type.model}"
+            delete_permission = f"{content_type.app_label}.delete_{content_type.model}"
+
+            if not self.request.user.has_perm(change_permission):
+                with suppress(KeyError):
+                    buttons.remove(Button.SAVE.value)
+
+            if not self.request.user.has_perm(delete_permission):
+                with suppress(KeyError):
+                    buttons.remove(Button.DELETE.value)
+
+            yield from self.order_buttons(buttons, self.INSTANCE_BUTTONS_ORDERING)
+
+    # Create Button Configuration
+    CREATE_BUTTONS = frozenset(
+        {Button.SAVE.value, Button.SAVE_AND_CLOSE.value, Button.SAVE_AND_NEW.value, Button.RESET.value}
+    )
+    CREATE_BUTTONS_ORDERING = [
+        Button.SAVE.value,
+        Button.SAVE_AND_CLOSE.value,
+        Button.SAVE_AND_NEW.value,
+        Button.RESET.value,
+    ]
+
+    def get_create_buttons(self) -> Generator[None, str, None]:
+        buttons = set(self.CREATE_BUTTONS)
+        yield from self.order_buttons(buttons, self.CREATE_BUTTONS_ORDERING)
+
+    # Custom Instance Button Configuration
+    CUSTOM_INSTANCE_BUTTONS = frozenset()
+    CUSTOM_LIST_INSTANCE_BUTTONS = frozenset()
+    CUSTOM_EXTRA_BUTTONS = frozenset()
+
+    def get_custom_instance_buttons(self) -> set:
+        return set(self.CUSTOM_INSTANCE_BUTTONS)
+
+    def get_custom_list_instance_buttons(self) -> set:
+        return set(self.CUSTOM_LIST_INSTANCE_BUTTONS)
+
+    def _get_custom_instance_buttons(self) -> Generator:
+        custom_instance_buttons = set()
+        if self.instance:
+            custom_instance_buttons |= self.get_custom_instance_buttons()
+            if self.FSM_INSTANCE:
+                custom_instance_buttons |= self.get_fsm_buttons()
+
+        else:
+            custom_instance_buttons |= self.get_custom_list_instance_buttons()
+            if self.FSM_LIST:
+                custom_instance_buttons |= self.get_fsm_buttons()
+
+        yield from self.serialize(
+            custom_instance_buttons,
+            add_instance_button.send(
+                self.view.__class__, many=not self.instance, request=self.request, view=self.view, **self.view.kwargs
+            ),
+        )
+
+    def get_custom_extra_buttons(self) -> set:
+        return set(self.CUSTOM_EXTRA_BUTTONS)
+
+    def _get_custom_extra_buttons(self):
+        yield from self.serialize(
+            self.get_custom_extra_buttons(),
+            add_extra_button.send(
+                self.view.__class__, instance=self.instance, request=self.request, view=self.view, **self.view.kwargs
+            ),
+        )
+
+    # Custom Button Configuration
+    CUSTOM_BUTTONS = frozenset()
+
+    def get_custom_buttons(self) -> set:
+        return set(self.CUSTOM_BUTTONS)
+
+    def _get_custom_buttons(self):
+        yield from self.serialize(
+            self.get_custom_buttons(),
+            add_button.send(self.view.__class__, request=self.request, view=self.view, **self.view.kwargs),
+        )
+
+    def get_metadata(self) -> dict:
+        return {
+            "custom_instance": self._get_custom_instance_buttons(),
+            "custom": self._get_custom_buttons(),
+            "extra": self._get_custom_extra_buttons(),
+        }

wbcore/metadata/configs/display/__init__.py

@@ -0,0 +1,4 @@
+from .formatting import Condition, Formatting, FormattingRule
+from .instance_display import *
+from .list_display import Calendar, Field, Legend, LegendItem, ListDisplay, Tooltip, TreeGroupLevelOption
+from .view_config import DisplayIdentifierViewConfig, DisplayViewConfig

wbcore/metadata/configs/display/configs.py

@@ -0,0 +1,15 @@
+from rest_framework.request import Request
+from rest_framework.reverse import reverse
+from wbcore.configs.decorators import register_config
+
+
+@register_config
+def preset_config(request: Request) -> tuple[str, dict[str, str]]:
+    """We return the wbcore:preset endpoint. We have to add a dummy arg and remove it immediately, since this endpoint only supports endpoints with arguments"""
+
+    dummy_arg = "empty"
+    arg_len = len(dummy_arg) + 1  # +1 to account for the second trailing slash
+    endpoint = reverse("wbcore:preset", args=[dummy_arg], request=request)
+    endpoint = endpoint[: -1 * arg_len]
+
+    return "presets", {"endpoint": endpoint}

wbcore/metadata/configs/display/display.py

@@ -0,0 +1,234 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Iterable, Optional
+
+# Type Definitions
+GridArea = list[list[str]]
+SerializedField = dict[str, str | bool]
+SerializedCardLayout = dict[str, str | SerializedField | list[SerializedField]]
+SerializedTable = dict[str, str | bool]
+SerializedChart = dict[str, str]
+SerializedSection = list
+SerializedLayout = dict[str, str | SerializedSection | SerializedTable]
+SerializedItem = dict[str, str | dict[str, SerializedLayout]]
+
+
+class DisplayType(Enum):
+    FORM = "form"
+    TABLE = "table"
+    CHART = "chart"
+    CALENDAR = "calendar"
+
+
+class ItemType(Enum):
+    PAGE = "page"
+    TAB = "tab"
+
+
+class InvalidOperatorError(Exception):
+    pass
+
+
+class Operator(Enum):
+    S = "<"
+    SE = "<="
+    G = ">"
+    GE = ">="
+    E = "=="
+
+    @classmethod
+    def get_operator(cls, op: str) -> "Operator":
+        operator_dict = {o.value: o for o in cls}
+        try:
+            return operator_dict[op]
+        except KeyError:
+            raise InvalidOperatorError(f"`{op}` is not a valid operator")
+
+
+def fr(fractions: int) -> str:
+    return f"{fractions}fr"
+
+
+def px(pixels: int) -> str:
+    return f"{pixels}px"
+
+
+def pct(percent: float) -> str:
+    return f"{percent}%"
+
+
+def repeat(times: int, unit: str) -> str:
+    return f"repeat({times}, {unit})"
+
+
+def grid_definition(*units):
+    return " ".join(units)
+
+
+def layout_size(width: Optional[int] = None, operator: str | Operator = Operator.S) -> str:
+    if width is None:
+        return "default"
+
+    if isinstance(operator, str):
+        operator = Operator.get_operator(operator)
+
+    return f"{operator.value}{width}"
+
+
+@dataclass
+class Table:
+    key: str
+    editable: bool = False
+
+    def serialize(self) -> SerializedTable:
+        return {
+            "key": self.key,
+            "editable": self.editable,
+        }
+
+
+@dataclass
+class Chart:
+    key: str
+
+    def serialize(self) -> SerializedChart:
+        return {"key": self.key}
+
+
+@dataclass
+class Layout:  # This has to be renamed to FormLayout
+    grid_areas: GridArea
+    grid_columns: Optional[str] = None
+    grid_rows: Optional[str] = None
+    sections: list = field(default_factory=list)
+    tables: list[Table] = field(default_factory=list)
+    charts: list[Chart] = field(default_factory=list)
+
+    def serialize(self) -> SerializedLayout:
+        serialized_layout = {
+            "gridTemplateAreas": " ".join([f"'{' '.join(row)}'" for row in self.grid_areas]),
+            "sections": self.sections,
+            "tables": [table.serialize() for table in self.tables],
+            "charts": [chart.serialize() for chart in self.charts],
+        }
+
+        if self.grid_columns:
+            serialized_layout["gridTemplateColumns"] = self.grid_columns
+
+        if self.grid_rows:
+            serialized_layout["gridTemplateRows"] = self.grid_rows
+
+        return serialized_layout
+
+
+@dataclass
+class Field:
+    key: str
+    show_label: bool = True
+    label: str | None = None
+
+    def serialize(self) -> SerializedField:
+        serialized_field = {"key": self.key, "show_label": self.show_label}
+
+        if self.label and self.show_label:
+            serialized_field["label"] = self.label
+
+        return serialized_field
+
+
+# @dataclass
+# class TableLayout:
+#     def serialize(self) -> SerializedTableLayout:
+#         pass
+
+
+@dataclass
+class CardLayout:
+    title: Field
+    fields: list[Field] = field(default_factory=list)
+
+    color: str | None = None
+    background_color: str | None = None
+    image: str | None = None
+
+    def serialize(self) -> SerializedCardLayout:
+        serialized_layout = {"title": self.title.serialize(), "fields": [field.serialize() for field in self.fields]}
+
+        if self.color:
+            serialized_layout["color"] = self.color
+
+        if self.background_color:
+            serialized_layout["background_color"] = self.background_color
+
+        if self.image:
+            serialized_layout["image"] = self.image
+
+        return serialized_layout
+
+
+@dataclass
+class Item:
+    layouts: dict[str, Layout]
+    title: str = ""
+
+    def serialize(self) -> SerializedItem:
+        return {"title": self.title, "layout": {key: layout.serialize() for key, layout in self.layouts.items()}}
+
+
+@dataclass
+class Display:
+    display_type: DisplayType
+    items: Iterable[Item]  # Consider to also be able to just a layout to make it redundant to use an Item here
+    item_type: ItemType = ItemType.PAGE  # This can maybe also be nullable?
+
+    def serialize(self) -> dict[str, str | list[SerializedItem]]:
+        return {
+            "display_type": self.display_type.value,
+            "item_type": self.item_type.value,
+            "items": [item.serialize() for item in self.items],
+        }
+
+    def __iter__(self):
+        for item in self.items:
+            yield item.serialize()
+
+
+if __name__ == "__main__":
+    # display = Display(
+    #     display_type=DisplayType.FORM,
+    #     items=[
+    #         Item(
+    #             title="First Page",
+    #             layouts={
+    #                 layout_size(): Layout(
+    #                     grid_columns=repeat(6, fr(1)),
+    #                     grid_areas=[["status", "status", "status", "title", "period", "period"]],
+    #                 ),
+    #                 layout_size(400): Layout(
+    #                     grid_columns=repeat(3, fr(1)),
+    #                     grid_areas=[["status", "status", "status"], ["title", "period", "period"]],
+    #                 ),
+    #             },
+    #         )
+    #     ],
+    # )
+    # display = Display(
+    #     display_type=DisplayType.TABLE,
+    #     items=[
+    #         Item(
+    #             layouts={
+    #                 layout_size(): Layout(
+    #                     grid_columns=repeat(4, fr(1)),
+    #                     grid_areas=[
+    #                         ["period", "status", "title", "other_field"],
+    #                         ["period", "status", "title", "other_field1"],
+    #                     ],
+    #                 )
+    #             }
+    #         )
+    #     ],
+    # )
+    # print(display.serialize())
+    # print(list(display) == display.serialize())
+
+    print(layout_size(500, Operator.E))  # noqa: T201

wbcore/metadata/configs/display/formatting.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+
+from wbcore.enums import Operator
+
+
+@dataclass(unsafe_hash=True)
+class Condition:
+    operator: Operator
+    value: str | float | int | bool
+
+    def __post_init__(self) -> None:
+        if self.operator == Operator.EXISTS:
+            assert isinstance(self.value, bool), f"{Operator.EXISTS.value} is only compatible with bool"
+
+
+@dataclass(unsafe_hash=True)
+class FormattingRule:
+    icon: str | None = None
+    style: dict | None = None
+    condition: Condition | tuple | list[tuple] | None = None
+
+    def __post_init__(self) -> None:
+        assert self.icon or self.style, "icon and style cannot both be None."
+
+    def __iter__(self):
+        yield "icon", self.icon
+        yield "style", self.style
+        if self.condition:
+            if isinstance(self.condition, tuple):
+                yield "condition", self.condition
+            elif isinstance(self.condition, list):
+                yield "condition", [tuple(cond) for cond in self.condition]
+            else:
+                yield "condition", (self.condition.operator.value, self.condition.value)
+
+
+@dataclass(unsafe_hash=True)
+class Formatting:
+    formatting_rules: list[FormattingRule]
+    column: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.column is None:
+            assert all(
+                [not bool(rule.condition) for rule in self.formatting_rules]
+            ), "Specifying conditions, without a reference column is not possible."
+
+    def __iter__(self):
+        yield "column", self.column
+        yield "formatting_rules", [dict(rule) for rule in self.formatting_rules]

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

@@ -0,0 +1,15 @@
+from . import operators as op
+from .display import Display
+from .enums import NavigationType
+from .layouts import Inline, Layout, Section
+from .pages import Page
+from .shortcuts import create_simple_display, create_simple_section
+from .operators import default
+from .styles import Style
+from .utils import (
+    grid_definition,
+    repeat,
+    repeat_field,
+    split_list_into_grid_template_area_sublists,
+)
+from .signals import add_display_pages