wbcore 1.46.0__py2.py3-none-any.whl → 1.58.2__py2.py3-none-any.whl

wbcore/markdown/models.py

@@ -17,7 +17,15 @@ class Asset(models.Model):
     file = models.FileField(max_length=256, upload_to=upload_to)
     content_type = models.CharField(max_length=32, null=True, blank=True)
     file_url_name = models.CharField(max_length=1024, null=True, blank=True)
+
     # public = models.BooleanField(default=True)
+    class Meta:
+        verbose_name = _("Asset")
+        verbose_name_plural = _("Assets")
+        db_table = "bridger_asset"
+
+    def __str__(self) -> str:
+        return str(self.id)
 
     @property
     def filename(self):
@@ -25,11 +33,6 @@ class Asset(models.Model):
             return f"{self.id}{suffix}"
         return self.id
 
-    class Meta:
-        verbose_name = _("Asset")
-        verbose_name_plural = _("Assets")
-        db_table = "bridger_asset"
-
 
 @receiver(models.signals.pre_save, sender="wbcore.Asset")
 def generate_content_type(sender, instance, **kwargs):

wbcore/markdown/views.py

@@ -48,7 +48,7 @@ class AssetCreateView(APIView):
         try:
             asset = Asset.objects.create(file=request.data["file"])
             return Response(reverse("wbcore:asset-retrieve", args=[asset.id], request=request))
-        except KeyError:
+        except (KeyError, AttributeError):
             return Response("file missing", status=400)
 
 

wbcore/menus/menus.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from django.utils.http import urlencode
 from rest_framework.request import Request
@@ -32,7 +32,7 @@ class MenuItem:
     endpoint: str
     endpoint_args: List[str] = field(default_factory=list)
     endpoint_kwargs: Dict[str, str] = field(default_factory=dict)
-    endpoint_get_parameters: Dict[str, str] = field(default_factory=dict)
+    endpoint_get_parameters: Callable | Dict[str, Any] = field(default_factory=dict)
     reverse: bool = True
 
     permission: Optional[ItemPermission] = None

wbcore/metadata/configs/buttons/bases.py

@@ -24,8 +24,8 @@ class ButtonConfig:
     def __post_init__(self):
         if post_init := getattr(super(), "__post_init__", None):
             post_init()
-
-        assert self.label or self.icon, "Either label or icon has to be defined."
+        if not self.label and not self.icon:
+            raise ValueError("No label or icon specified")
 
     def __iter__(self):
         if iter := getattr(super(), "__iter__", None):
@@ -37,7 +37,10 @@ class ButtonConfig:
                 yield key, value
         color = getattr(self.color, "value", self.color)
         yield "color", color
-        yield "level", color  # TODO: we return level for backward compatibility reason. to be removed once we move to frontend version 2
+        yield (
+            "level",
+            color,
+        )  # TODO: we return level for backward compatibility reason. to be removed once we move to frontend version 2
         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
@@ -54,8 +57,8 @@ class ButtonTypeMixin:
     def __post_init__(self):
         if post_init := getattr(super(), "__post_init__", None):
             post_init()
-
-        assert hasattr(self, "button_type"), "button_type cannot be None."
+        if not hasattr(self, "button_type"):
+            raise TypeError("button_type cannot be None.")
 
     def __iter__(self):
         if iter := getattr(super(), "__iter__", None):
@@ -79,8 +82,8 @@ class ButtonUrlMixin:
     def __post_init__(self):
         if post_init := getattr(super(), "__post_init__", None):
             post_init()
-
-        assert bool(self.key) != bool(self.endpoint), "Either key or endpoint has to be defined. (Not both)"
+        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):

wbcore/metadata/configs/buttons/buttons.py

@@ -23,7 +23,8 @@ class DropDownButton(ButtonTypeMixin, ButtonConfig):
         if hasattr(super(), "__post_init__"):
             super().__post_init__()
         self.buttons = tuple(self.buttons)
-        assert isinstance(self.buttons, tuple)
+        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)

wbcore/metadata/configs/buttons/enums.py

@@ -1,6 +1,56 @@
 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"

wbcore/metadata/configs/buttons/view_config.py

@@ -1,8 +1,6 @@
-from contextlib import suppress
-from typing import Generator
+from typing import Generator, Iterable
 
 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,
@@ -12,9 +10,12 @@ from wbcore.signals.instance_buttons import (
 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"
 
@@ -28,7 +29,9 @@ class ButtonViewConfig(WBCoreViewConfig):
         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
+        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))
 
@@ -53,57 +56,20 @@ class ButtonViewConfig(WBCoreViewConfig):
     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:
+        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),
+                    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 = frozenset({Button.SAVE.value})
     CREATE_BUTTONS_ORDERING = [
         Button.SAVE.value,
         Button.SAVE_AND_CLOSE.value,
@@ -111,7 +77,7 @@ class ButtonViewConfig(WBCoreViewConfig):
         Button.RESET.value,
     ]
 
-    def get_create_buttons(self) -> Generator[None, str, None]:
+    def get_create_buttons(self) -> Iterable:
         buttons = set(self.CREATE_BUTTONS)
         yield from self.order_buttons(buttons, self.CREATE_BUTTONS_ORDERING)
 
@@ -172,7 +138,8 @@ class ButtonViewConfig(WBCoreViewConfig):
         return {
             "custom_instance": self._get_custom_instance_buttons(),
             "custom": self._get_custom_buttons()
-            if not self.view.inline
+            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/display.py

@@ -41,8 +41,8 @@ class Operator(Enum):
         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")
+        except KeyError as e:
+            raise InvalidOperatorError(f"`{op}` is not a valid operator") from e
 
 
 def fr(fractions: int) -> str:

wbcore/metadata/configs/display/formatting.py

@@ -9,21 +9,20 @@ class Condition:
     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"
+        if self.operator == Operator.EXISTS and not isinstance(self.value, bool):
+            raise TypeError(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."
+        if not self.style:
+            raise ValueError("Style cannot be empty")
 
     def __iter__(self):
-        yield "icon", self.icon
         yield "style", self.style
         if self.condition:
             if isinstance(self.condition, tuple):
@@ -40,10 +39,8 @@ class Formatting:
     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."
+        if self.column is None and not all([not bool(rule.condition) for rule in self.formatting_rules]):
+            raise ValueError("Specifying conditions, without a reference column is not possible.")
 
     def __iter__(self):
         yield "column", self.column

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

@@ -17,7 +17,9 @@ class Display:
     pages: Iterable[Page]
     navigation_type: NavigationType = NavigationType.TAB
 
-    def serialize(self, view_config=None, view=None, request=None, key_prefix=None) -> SerializedDisplay:
+    def serialize(
+        self, view_config=None, view=None, request=None, key_prefix=None, parent_page=None
+    ) -> SerializedDisplay:
         """Serializes a `Display`
 
         Returns:
@@ -28,7 +30,8 @@ class Display:
             page.serialize(key_prefix=key_prefix, view_config=view_config, view=view, request=request)
             for page in self.pages
         ]
-        if view_config:
+        # we only allow remote page registration if the display is the top display. We could argue that we want to allow dev to register pages for any nested display by passing down the page argument. This involves refactoring of the signal receivers
+        if view_config and parent_page is None:
             for prefix, remote_pages in parse_signal_received_for_module(
                 add_display_pages.send(view_config.__class__, request=request, view=view)
             ):

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

@@ -34,7 +34,7 @@ class Page:
 
         elif self.display is not None:
             page["display"] = self.display.serialize(
-                view_config=view_config, view=view, request=request, key_prefix=key_prefix
+                view_config=view_config, view=view, request=request, key_prefix=key_prefix, parent_page=self
             )
 
         return page

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

@@ -43,7 +43,7 @@ def create_simple_section(
     grid_template_areas: list[list[str]] | None = None,
     inline_key: str | None = None,
     extra_display_kwargs: dict | None = None,
-    **kwargs
+    **kwargs,
 ) -> Section:
     """Creates a simple section without having to specify everything
 

wbcore/metadata/configs/display/list_display.py

@@ -1,6 +1,8 @@
 from dataclasses import dataclass, field
 from typing import Iterable, Literal, Optional
 
+from slugify import slugify
+
 from wbcore.metadata.configs.display.formatting import Formatting, FormattingRule
 
 
@@ -34,7 +36,7 @@ class Tooltip:
 
 @dataclass(unsafe_hash=True)
 class Field:
-    key: str
+    key: str | None
     label: str
     formatting_rules: Iterable[FormattingRule] = field(default_factory=list)
     width: int | None = None
@@ -56,6 +58,11 @@ class Field:
     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:
@@ -66,50 +73,55 @@ class Field:
         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]
+    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:
-            yield "width", self.width
+            repr["width"] = self.width
 
         if self.hide:
-            yield "hide", self.hide
+            repr["hide"] = self.hide
 
         if self.pinned and self.pinned in ["left", "right"]:
-            yield "pinned", self.pinned
+            repr["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
+            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:
-            yield "show", self.show
+            repr["show"] = self.show
 
         if self.open_by_default is not None:
-            yield "open_by_default", self.open_by_default
+            repr["open_by_default"] = self.open_by_default
 
         if not self.movable:
-            yield "movable", self.movable
+            repr["movable"] = self.movable
 
         if not self.resizable:
-            yield "resizable", self.resizable
+            repr["resizable"] = self.resizable
 
         if self.lock_position:
-            yield "lock_position", self.lock_position
+            repr["lock_position"] = self.lock_position
 
         if not self.auto_size:
-            yield "auto_size", self.auto_size
+            repr["auto_size"] = self.auto_size
 
         if not self.menu:
-            yield "menu", self.menu
+            repr["menu"] = self.menu
 
         if not self.size_to_fit:
-            yield "size_to_fit", self.size_to_fit
+            repr["size_to_fit"] = self.size_to_fit
 
         if self.tooltip:
-            yield "tooltip", self.tooltip.serialize()
+            repr["tooltip"] = self.tooltip.serialize()
+        return repr
 
 
 @dataclass(unsafe_hash=True)
@@ -133,10 +145,8 @@ class Legend:
     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."
+        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:
@@ -148,11 +158,8 @@ class Legend:
         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
+@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)
@@ -162,10 +169,26 @@ class TreeGroupLevelOption:
         # 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
@@ -174,12 +197,7 @@ class TreeGroupLevelOption:
             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
 
@@ -198,14 +216,12 @@ class ListDisplay:
     auto_height: bool = False
 
     tree: bool = False
-    tree_group_pinned: str = "left"
     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_label: str | None = None
     tree_group_open_level: int = 0
     tree_group_field_sortable: bool = False
 
@@ -219,7 +235,7 @@ class ListDisplay:
 
     def __iter__(self):
         yield "editable", self.editable
-        yield "fields", [dict(field) for field in self.fields if field]
+        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
@@ -233,9 +249,7 @@ class ListDisplay:
         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,
+                "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,

wbcore/metadata/configs/display/models.py

@@ -10,6 +10,9 @@ class Preset(models.Model):
     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)
@@ -18,3 +21,6 @@ class AppliedPreset(models.Model):
         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

@@ -53,13 +53,9 @@ class DisplayViewConfig(WBCoreViewConfig):
         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(
+        display_identifier_path = 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]))
+        ).display_identifier_path()
 
         with suppress(AppliedPreset.DoesNotExist):
             display["preset"] = AppliedPreset.objects.get(
@@ -73,11 +69,17 @@ class DisplayIdentifierViewConfig(WBCoreViewConfig):
     metadata_key = "display_identifier"
     config_class_attribute = "display_identifier_config_class"
 
-    def get_display_identifier(self) -> str:
+    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__)
-        return f"{slugified_display_module}-{slugified_display_class}"
+        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.get_display_identifier()
+        return self.display_identifier_path()