wbcore 1.59.9__py2.py3-none-any.whl

wbcore/metadata/configs/base.py

@@ -0,0 +1,86 @@
+from typing import TYPE_CHECKING, Any, Iterable
+
+from django.utils.functional import cached_property
+from rest_framework.request import Request
+from rest_framework.views import View
+
+if TYPE_CHECKING:
+    from wbcore.contrib.authentication.models import User
+    from wbcore.contrib.directory.models import Person
+
+
+class WBCoreViewConfig:
+    """A class to configure a View in the WBCore application"""
+
+    metadata_key: str
+    config_class_attribute: str
+
+    def __init__(self, view: View, request: Request, instance: bool | None = None):
+        """
+        Initializes an instance of WBCoreViewConfig.
+
+        Args:
+            view (View): A Django Rest Framework view.
+            request (Request): An HTTP request instance.
+        """
+        self.view = view
+        self.request = request
+        self.instance = instance if instance else "pk" in view.kwargs
+        self.new_mode = request.GET.get("new_mode", "false") == "true"
+
+    @cached_property
+    def user(self) -> "User":
+        return self.request.user
+
+    @cached_property
+    def profile(self) -> "Person":
+        return self.user.profile
+
+    def get_metadata(self) -> Any:
+        raise NotImplementedError()
+
+    def _get_metadata(self) -> Any:
+        return self.get_metadata()
+
+    @classmethod
+    def get_all_configs(cls, view: View) -> Iterable[tuple[str, "WBCoreViewConfig"]]:
+        """
+        Returns an iterator of tuples containing all the WBCoreViewConfig
+        instances associated with the given view.
+
+        Args:
+            view (View): A Django Rest Framework view.
+
+        Returns:
+            An iterator of tuples, where each tuple contains a string with the
+            name of the configuration attribute and the corresponding
+            WBCoreViewConfig instance.
+        """
+        yield from map(
+            lambda c: (c.config_class_attribute, c),
+            filter(lambda x: getattr(view, x.config_class_attribute), view.config_classes),
+        )
+
+    @classmethod
+    def for_view(cls, view: View, request: Request) -> "WBCoreViewConfig":
+        """
+        Returns the WBCoreViewConfig instance associated with the given view.
+
+        Args:
+            view (View): A Django Rest Framework view.
+            request (Request): An HTTP request instance.
+
+        Returns:
+            The WBCoreViewConfig instance associated with the given view.
+        """
+        return getattr(view, cls.config_class_attribute)(view, request)
+
+    @classmethod
+    def as_view_mixin(cls) -> type:
+        """
+        Returns a mixin class that adds the configuration attribute to a view.
+
+        Returns:
+            A mixin class that adds the configuration attribute to a view.
+        """
+        return type(f"{cls.__name__}Mixin", (), {cls.config_class_attribute: cls})

wbcore/metadata/configs/buttons/__init__.py

@@ -0,0 +1,4 @@
+from .bases import ButtonConfig
+from .buttons import ActionButton, DropDownButton, HyperlinkButton, WidgetButton
+from .enums import ButtonDefaultColor, ButtonType
+from .view_config import ButtonViewConfig

wbcore/metadata/configs/buttons/bases.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from wbcore.metadata.utils import prefix_key
+
+from .enums import ButtonDefaultColor
+
+
+@dataclass
+class ButtonConfig:
+    label: Optional[str] = None
+    icon: Optional[str] = None
+    title: Optional[str] = None
+    color: ButtonDefaultColor | str = ButtonDefaultColor.PRIMARY
+    weight: int = 100
+    disabled: bool = False
+    always_render: bool = False
+    placeholder: str | None = None
+
+    def __hash__(self):
+        return hash(self.title)
+
+    def __post_init__(self):
+        if post_init := getattr(super(), "__post_init__", None):
+            post_init()
+        if not self.label and not self.icon:
+            raise ValueError("No label or icon specified")
+
+    def __iter__(self):
+        if iter := getattr(super(), "__iter__", None):
+            yield from iter()
+
+        for key in ["label", "icon", "title"]:
+            value = getattr(self, key, None)
+            if value:
+                yield key, value
+        color = getattr(self.color, "value", self.color)
+        yield "color", color
+        yield "disabled", self.disabled  # set to True if you want to set the css "disabled" property to that button
+        yield "always_render", self.always_render  # set to True the button always needs to be rendered (even if empty)
+        yield "placeholder", self.placeholder  # set to a valid string if a placeholder is needed onhover
+
+    def serialize(self, request, key_prefix: str = None):
+        res = dict(self)
+        if key_prefix and "key" in res:
+            res["key"] = prefix_key(res["key"], key_prefix)
+        return res
+
+
+@dataclass
+class ButtonTypeMixin:
+    def __post_init__(self):
+        if post_init := getattr(super(), "__post_init__", None):
+            post_init()
+        if not hasattr(self, "button_type"):
+            raise TypeError("button_type cannot be None.")
+
+    def __iter__(self):
+        if iter := getattr(super(), "__iter__", None):
+            yield from iter()
+
+        if button_type := getattr(self, "button_type", None):
+            yield "type", button_type.value
+
+
+@dataclass
+class ButtonUrlMixin:
+    key: Optional[str] = None
+    endpoint: Optional[str] = None
+
+    def __hash__(self):
+        if self.key:
+            return hash(self.key)
+        else:
+            return hash(self.endpoint)
+
+    def __post_init__(self):
+        if post_init := getattr(super(), "__post_init__", None):
+            post_init()
+        if bool(self.key) == bool(self.endpoint):
+            raise ValueError("Either key or endpoint has to be defined. (Not both)")
+
+    def __iter__(self):
+        if iter := getattr(super(), "__iter__", None):
+            yield from iter()
+        if self.key:
+            yield "key", self.key
+        if self.endpoint:
+            yield "endpoint", self.endpoint

wbcore/metadata/configs/buttons/buttons.py

@@ -0,0 +1,138 @@
+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
+
+
+@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)
+        if not isinstance(self.buttons, tuple):
+            raise TypeError(f"{type(self.buttons)} is not a 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
+
+    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,68 @@
+from enum import Enum
+
+
+class Button(Enum):
+    # Buttons
+    REFRESH = "refresh"
+    NEW = "new"
+    DELETE = "delete"
+
+    # Buttons and Create Buttons
+    SAVE = "save"
+    SAVE_AND_CLOSE = "save_and_close"
+    SAVE_AND_NEW = "save_and_new"
+
+    # Create Buttons
+    RESET = "reset"
+
+    # Custom Buttons
+    DROPDOWN = "dropdown"
+    HYPERLINK = "hyperlink"
+    WIDGET = "widget"
+    ACTION = "action"
+
+    @classmethod
+    def buttons(cls):
+        return [
+            cls.REFRESH.value,
+            cls.NEW.value,
+            cls.DELETE.value,
+            cls.SAVE.value,
+            cls.SAVE_AND_CLOSE.value,
+            cls.SAVE_AND_NEW.value,
+        ]
+
+    @classmethod
+    def create_buttons(cls):
+        return [
+            cls.SAVE.value,
+            cls.SAVE_AND_CLOSE.value,
+            cls.SAVE_AND_NEW.value,
+            cls.RESET.value,
+        ]
+
+    @classmethod
+    def custom_buttons(cls):
+        return [
+            cls.DROPDOWN.value,
+            cls.HYPERLINK.value,
+            cls.WIDGET.value,
+            cls.ACTION.value,
+        ]
+
+
+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"

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,145 @@
+from typing import Generator, Iterable
+
+from wbcore.contrib.icons import WBIcon
+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
+from .enums import Button
+
+
+class ButtonViewConfig(WBCoreViewConfig):
+    SHOW_INLINE: bool = False  # set to true if the class needs to show custom button on inline
+
+    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, strict=False)
+        )  # 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 := 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())
+
+    # Create Button Configuration
+    CREATE_BUTTONS = frozenset({Button.SAVE.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) -> Iterable:
+        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()
+            if (not self.view.inline or self.SHOW_INLINE)
+            else [],  # we do not show button for list display generated through inline
+            "extra": self._get_custom_extra_buttons(),
+            "save": self.get_create_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,16 @@
+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}