wbcore 2.2.1__py2.py3-none-any.whl

wbcore/markdown/template.py

@@ -0,0 +1,38 @@
+from django.conf import settings
+from django.template import Context, Template
+from django.utils.safestring import SafeString
+from markdown import markdown
+
+
+def load_registered_templatetags() -> str:
+    """Assembles the templatetags that are registered to wbcore in the django load format"""
+    if templatetags := settings.WBCORE_MARKDOWN_TEMPLATE_TAGS or "":
+        templatetags = f"{{% load {' '.join(templatetags)} %}}"
+
+    return templatetags
+
+
+def compile_template_for_templatetag(templatetag: str) -> Template:
+    """Compiles a template with the registered templatetags to resolve a single templatetag"""
+    return Template(load_registered_templatetags() + templatetag)
+
+
+def render_template_for_templatetag(templatetag: str, **context) -> SafeString:
+    """Renders a template for a single templatetag"""
+    template = compile_template_for_templatetag(templatetag)
+    return template.render(Context(context))
+
+
+def resolve_templatetags(content: str, **context) -> str:
+    """Resolves all templatetags of some content"""
+    return Template(load_registered_templatetags() + content).render(Context(context))
+
+
+def resolve_markdown(content: str, extensions=None) -> str:
+    """Resolves the markdown of some content"""
+    return markdown(content, extensions=extensions)
+
+
+def resolve_content(content: str, extensions=None, **context) -> str:
+    """Resolves the content by first resolving the templatetags and then resolving any potential markdown fields"""
+    return resolve_markdown(resolve_templatetags(content, **context), extensions=extensions)

wbcore/markdown/utils.py

@@ -0,0 +1,36 @@
+import re
+
+from dynamic_preferences.registries import global_preferences_registry
+from wbcore.markdown.models import Asset
+from weasyprint import default_url_fetcher
+
+
+def custom_url_fetcher(url):
+    try:
+        if s := re.search(
+            r".*wbcore/markdown/asset/([0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12})",
+            url,
+        ):
+            asset = Asset.objects.get(id=s.group(1))
+            url = asset.file.url
+        return default_url_fetcher(url)
+    except Exception:
+        global_preferences = global_preferences_registry.manager()
+        default_placeholder_url = global_preferences.get("wbcore__default_empty_image_placeholder", no_cache=True)
+        return default_url_fetcher(default_placeholder_url)
+
+
+def remove_styled_table(html_content):
+    tags = ["table", "col", "td"]
+    for tag in tags:
+        reg_str = "<" + tag + "(.*?)" + ">"
+        reg_style = '(style=".*?;")'
+        _attributs = re.findall(reg_str, html_content)
+        dict_attrs = {}
+        for attribut in _attributs:
+            dict_attrs[attribut] = re.sub(reg_style, "", attribut)
+
+        for _key, _value in dict_attrs.items():
+            html_content = re.sub(_key, _value, html_content)
+
+    return html_content

wbcore/markdown/views.py

@@ -0,0 +1,67 @@
+from blockdiag.parser import ParseException
+from django.core.exceptions import ValidationError
+from django.http import HttpResponse
+from django.template import exceptions
+from markdown_blockdiag.utils import draw_blockdiag
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework.views import APIView
+
+from .models import Asset
+from .template import render_template_for_templatetag
+
+
+class BlockDiag(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def post(self, request: Request) -> Response:
+        try:
+            blockdiag = request.data["markdown"]
+            svg = draw_blockdiag(blockdiag, output_fmt="svg", font_antialias=True)
+        except (ParseException, KeyError):
+            return Response(status=status.HTTP_400_BAD_REQUEST)
+        else:
+            return Response(svg)
+
+
+class TemplateTagView(APIView):
+    permission_classes = []
+
+    def post(self, request: Request) -> Response:
+        if templatetag := request.data.get("templatetag"):
+            try:
+                return Response(render_template_for_templatetag(templatetag, request=request))
+            except exceptions.TemplateSyntaxError:
+                return Response("malformatted templatetag", status=400)
+            except Exception:
+                return Response("not handled exception", status=400)
+        return Response("templatetag missing", status=400)
+
+
+class AssetCreateView(APIView):
+    permission_classes = []
+
+    def post(self, request: Request) -> Response:
+        try:
+            asset = Asset.objects.create(file=request.data["file"])
+            return Response(reverse("wbcore:asset-retrieve", args=[asset.id], request=request))
+        except KeyError:
+            return Response("file missing", status=400)
+
+
+class AssetRetrieveView(APIView):
+    permission_classes = []
+
+    def get(self, request: Request, uuid: str) -> Response:
+        try:
+            asset = Asset.objects.get(id=uuid)
+            response = HttpResponse(asset.file, content_type=asset.content_type)
+            response["Content-Disposition"] = f"attachment; filename={asset.file_url_name}"
+            return response
+        except Asset.DoesNotExist:
+            return Response(status=404)
+        except ValidationError as e:
+            return Response(*e, status=400)

wbcore/menus/__init__.py

@@ -0,0 +1,2 @@
+from .menus import ItemPermission, Menu, MenuItem
+from .registry import default_registry

wbcore/menus/menus.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional, Union
+
+from django.utils.http import urlencode
+from rest_framework.request import Request
+from rest_framework.reverse import reverse
+
+
+@dataclass
+class ItemPermission:
+    permissions: List[str] = field(default_factory=list)
+    method: Optional[Callable] = None
+
+    def has_permission(self, request: Request) -> bool:
+        if request.user.is_superuser:
+            return True
+
+        for permission in self.permissions:
+            if not request.user.has_perm(permission):
+                return False
+
+        if self.method:
+            return self.method(request=request)
+
+        return True
+
+
+@dataclass
+class MenuItem:
+    label: str
+
+    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)
+    reverse: bool = True
+
+    permission: Optional[ItemPermission] = None
+    add: Optional["MenuItem"] = None
+
+    index: Optional[int] = None
+    new_mode: bool = False
+
+    def __iter__(self):
+        request = getattr(self, "request", None)
+
+        if self.permission is None or self.permission.has_permission(request=request):
+            if self.reverse:
+                endpoint = reverse(
+                    viewname=self.endpoint,
+                    args=self.endpoint_args,
+                    kwargs=self.endpoint_kwargs,
+                    request=request,
+                )
+            else:
+                endpoint = self.endpoint
+
+            endpoint_get_parameters = self.endpoint_get_parameters
+            if callable(endpoint_get_parameters):
+                endpoint_get_parameters = endpoint_get_parameters(request)
+            if self.new_mode:
+                endpoint_get_parameters["new_mode"] = True
+
+            if endpoint_get_parameters:
+                endpoint_get_parameters = {
+                    k: str(v).lower() if isinstance(v, bool) else v for k, v in endpoint_get_parameters.items()
+                }
+                endpoint += f"?{urlencode(endpoint_get_parameters)}"
+            yield "label", self.label
+            yield "endpoint", endpoint
+            if self.add:
+                self.add.request = request
+                self.add.new_mode = True
+                if dict(self.add):
+                    yield "add", dict(self.add)
+
+
+@dataclass
+class Menu:
+    label: str
+    items: List[Union[MenuItem, "Menu"]] = field(default_factory=list)
+
+    index: Optional[int] = None
+
+    def __iter__(self):
+        request = getattr(self, "request", None)
+        items = list()
+        for item in filter(lambda x: bool(x), self.items):
+            item.request = request
+            serialized_item = dict(item)
+            if serialized_item:
+                items.append(serialized_item)
+
+        if len(items) > 0:
+            yield "label", self.label
+            yield "items", items

wbcore/menus/registry.py

@@ -0,0 +1,28 @@
+from .menus import Menu, MenuItem
+
+
+class MenuRegistry:
+    def __init__(self):
+        self._registry = list()
+
+    def clear(self):
+        self._registry = list()
+
+    def register(self, menu: Menu | MenuItem):
+        self._registry.append(menu)
+
+    def __iter__(self):
+        request = getattr(self, "request", None)
+        if getattr(self, "alphabetical_sorted", False):
+            menus = sorted(filter(lambda x: bool(x), self._registry), key=lambda x: x.label)
+        else:
+            menus = sorted(filter(lambda x: bool(x), self._registry), key=lambda x: (x.index is None, x.index))
+
+        for menu in menus:
+            menu.request = request
+            serialized_menu = dict(menu)
+            if serialized_menu != {}:
+                yield serialized_menu
+
+
+default_registry = MenuRegistry()

wbcore/menus/views.py

@@ -0,0 +1,41 @@
+import importlib
+import sys
+from contextlib import suppress
+
+from django.conf import settings
+from django.utils.module_loading import import_string
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from .registry import default_registry
+
+
+class MenuAPIView(APIView):
+    @property
+    def permission_classes(self):
+        wbcore_auth = import_string(settings.WBCORE_DEFAULT_AUTH_CONFIG)(None)
+
+        if wbcore_auth["type"] is None:
+            return []
+
+        return [IsAuthenticated]
+
+    def get(self, request: Request) -> Response:
+        # Default menu is imported from menu. In case we need multiple menus (or provide a temporary new menu) we can
+        # steer this through an optional GET parameter
+
+        mod_name = f"{settings.PROJECT_NAME}.{request.COOKIES.get('menu', 'menu')}"
+
+        default_registry.clear()
+
+        # Trying to import the menu from the project folder (only if it is called config)
+        with suppress(ModuleNotFoundError):
+            if mod := sys.modules.get(mod_name, None):
+                importlib.reload(mod)
+            else:
+                importlib.import_module(mod_name)
+
+        default_registry.request = request
+        return Response(list(default_registry))

wbcore/messages.py

@@ -0,0 +1,51 @@
+from typing import Iterable
+
+from django.contrib.messages.storage.base import BaseStorage, Message
+
+MESSAGE_TYPE_MAPPING = {
+    10: "debug",
+    20: "info",
+    25: "success",
+    30: "warning",
+    40: "error",
+}
+
+
+class InMemoryMessageStorage(BaseStorage):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._messages = []
+
+    def _get(self, *args, **kwargs):
+        """
+        Retrieve a list of messages. Returns a tuple of (messages, all_retrieved).
+        """
+        return self._messages, True
+
+    def _store(self, messages, *args, **kwargs):
+        """
+        Store a list of messages.
+        """
+        self._messages = messages
+
+    def add(self, level, message, extra_tags="", *args, **kwargs):
+        """
+        Adds a message to the storage.
+        """
+        if not message:
+            return
+        message_instance = Message(level, message, extra_tags=extra_tags)
+        self._messages.append(message_instance)
+
+    def __iter__(self):
+        return iter(self._messages)
+
+    def serialize_messages(self) -> Iterable[dict[str, str | int]]:
+        for message in self._messages:
+            extra_parameters = dict([param.split("=") for param in message.extra_tags.split(" ") if param != ""])
+            auto_close = int(extra_parameters.get("auto_close", "5")) * 1000
+            yield {
+                "message": message.message,
+                "type": MESSAGE_TYPE_MAPPING[message.level],
+                "auto_close": auto_close,
+            }

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, HyperlinkTarget
+from .view_config import ButtonViewConfig

wbcore/metadata/configs/buttons/bases.py

@@ -0,0 +1,91 @@
+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
+    style: Optional[dict] = 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()
+
+        assert self.label or self.icon, "Either label or icon has to be defined."
+
+    def __iter__(self):
+        if iter := getattr(super(), "__iter__", None):
+            yield from iter()
+
+        for key in ["label", "icon", "title", "style"]:
+            value = getattr(self, key, None)
+            if value:
+                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 "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()
+
+        assert hasattr(self, "button_type"), "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()
+
+        assert bool(self.key) != bool(self.endpoint), "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