wbcore 1.59.9__py2.py3-none-any.whl

wbcore/management/__init__.py

@@ -0,0 +1,88 @@
+from django.conf import settings
+from django.db import DEFAULT_DB_ALIAS, router
+from django.contrib.contenttypes.management import create_contenttypes
+from django.apps import apps as global_apps
+
+
+def _get_all_permissions(opts):
+    if action := getattr(settings, "IMPORT_EXPORT_IMPORT_PERMISSION_CODE", None):
+        yield "%s_%s" % (action, opts.model_name), "Import %s %s" % (action, opts.verbose_name_raw),
+    if action := getattr(settings, "IMPORT_EXPORT_EXPORT_PERMISSION_CODE", None):
+        yield "%s_%s" % (action, opts.model_name), "Export %s %s" % (action, opts.verbose_name_raw),
+
+    yield "select_%s" % (opts.model_name,), "Can select %s" % (opts.verbose_name_raw,)
+
+
+def create_wbcore_permissions(
+    app_config,
+    verbosity=2,
+    interactive=True,
+    using=DEFAULT_DB_ALIAS,
+    apps=global_apps,
+    **kwargs,
+):
+    if not app_config.models_module:
+        return
+
+    # Ensure that contenttypes are created for this app. Needed if
+    # 'django.contrib.auth' is in INSTALLED_APPS before
+    # 'django.contrib.contenttypes'.
+    create_contenttypes(
+        app_config,
+        verbosity=verbosity,
+        interactive=interactive,
+        using=using,
+        apps=apps,
+        **kwargs,
+    )
+
+    app_label = app_config.label
+    try:
+        app_config = apps.get_app_config(app_label)
+        ContentType = apps.get_model("contenttypes", "ContentType")
+        Permission = apps.get_model("auth", "Permission")
+    except LookupError:
+        return
+
+    if not router.allow_migrate_model(using, Permission):
+        return
+
+    # This will hold the permissions we're looking for as
+    # (content_type, (codename, name))
+    searched_perms = []
+    # The codenames and ctypes that should exist.
+    ctypes = set()
+    for klass in app_config.get_models():
+        # Force looking up the content types in the current database
+        # before creating foreign keys to them.
+        ctype = ContentType.objects.db_manager(using).get_for_model(klass, for_concrete_model=False)
+
+        ctypes.add(ctype)
+        for perm in _get_all_permissions(klass._meta):
+            searched_perms.append((ctype, perm))
+
+    # Find all the Permissions that have a content_type for a model we're
+    # looking for.  We don't need to check for codenames since we already have
+    # a list of the ones we're going to create.
+    all_perms = set(
+        Permission.objects.using(using)
+        .filter(
+            content_type__in=ctypes,
+        )
+        .values_list("content_type", "codename")
+    )
+
+    perms = []
+    for ct, (codename, name) in searched_perms:
+        if (ct.pk, codename) not in all_perms:
+            permission = Permission()
+            permission._state.db = using
+            permission.codename = codename
+            permission.name = name
+            permission.content_type = ct
+            perms.append(permission)
+
+    Permission.objects.using(using).bulk_create(perms)
+    if verbosity >= 2:
+        for perm in perms:
+            print("Adding permission '%s'" % perm)

wbcore/management/commands/bootstrap.py

@@ -0,0 +1,18 @@
+from importlib import import_module
+from os import environ
+
+from django.core.management import call_command
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Bootstrap the current module"
+
+    def handle(self, *args, **options):
+        self.stdout.write("Migrating Database")
+        call_command("migrate")
+        settings = import_module(str(environ.get("DJANGO_SETTINGS_MODULE")))
+        self.stdout.write("Loading Fixtures...")
+        for fixture in getattr(settings, "BOOTSTRAP_FIXTURES", []):
+            self.stdout.write(f"Load {fixture}: ", ending="")
+            call_command("loaddata", fixture)

wbcore/management/commands/clean_obsolete_object.py

@@ -0,0 +1,21 @@
+from django.apps import apps
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+    help = "Delete all objects (obtained using content type and object id) whose related item was deleted"
+
+    def add_arguments(self, parser):
+        parser.add_argument("app", type=str)
+        parser.add_argument("model", type=str)
+        parser.add_argument("--field", type=str)
+
+    def handle(self, *args, **options):
+        model_class = apps.get_model(app_label=options["app"], model_name=options["model"])
+        field = options["field"] if options["field"] else "content_object"
+
+        for object in model_class.objects.all():
+            if not getattr(object, field, None):
+                object.delete()
+
+        self.stdout.write("Deletion completed")

wbcore/management/commands/handle_release_notes.py

@@ -0,0 +1,54 @@
+import re
+from contextlib import suppress
+
+from django.core.management.base import BaseCommand
+from markdown import Markdown
+
+from wbcore.release_notes.models import ReleaseNote
+
+
+def parse_changelog(change_log_path: str, changelog_section_regex: str):
+    with open(change_log_path) as file:
+        section = ""
+        previous_matched_version = None
+        previous_matched_date = None
+
+        for line in file:
+            match = re.search(changelog_section_regex, line)
+            if match:
+                if previous_matched_version and previous_matched_date:
+                    yield previous_matched_version, previous_matched_date, section
+                section = ""
+                previous_matched_version = match.group(1)
+                previous_matched_date = match.group(2)
+            section += line + "\n"
+        if previous_matched_version and previous_matched_date:
+            yield previous_matched_version, previous_matched_date, section
+
+
+class Command(BaseCommand):
+    help = "Handles the creation/deletion/changing of release notes through markdown files"
+
+    def add_arguments(self, parser):
+        parser.add_argument("module_changelog_path_tuples", nargs="*", type=str, default=["stainly:CHANGELOG.md"])
+        parser.add_argument(
+            "changelog_section_regex", nargs="?", type=str, default=r"^##\sv?(\d+\.\d+\.\d+).*(\d{4}-\d{2}-\d{2}).*$"
+        )
+
+    def handle(self, *args, **options):
+        for module_changelog_path_tuple in options["module_changelog_path_tuples"]:
+            module, changelog_path = module_changelog_path_tuple.split(":")
+            stale_release_notes = ReleaseNote.objects.filter(module=module)
+            with suppress(FileNotFoundError):
+                for version, release_date, section in parse_changelog(
+                    changelog_path, options["changelog_section_regex"]
+                ):
+                    md = Markdown(extensions=["meta"], tab_length=2)
+                    content = md.convert(section)
+                    release_note_obj, created = ReleaseNote.objects.update_or_create(
+                        version=version,
+                        module=module,
+                        defaults={"release_date": release_date, "summary": f"v{version}", "notes": content},
+                    )
+                    stale_release_notes = stale_release_notes.exclude(id=release_note_obj.id)
+                stale_release_notes.delete()

wbcore/markdown/__init__.py

@@ -0,0 +1 @@
+from .dynamic_preferences_registry import *

wbcore/markdown/admin.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+
+from .models import Asset
+
+
+@admin.register(Asset)
+class AssetModelAdmin(admin.ModelAdmin):
+    list_display = ("id", "file", "content_type")
+    readonly_fields = ("content_type", "file_url_name")

wbcore/markdown/dynamic_preferences_registry.py

@@ -0,0 +1,16 @@
+from django.utils.translation import gettext as _
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import StringPreference
+
+wbcore_section = Section("wbcore")
+
+
+@global_preferences_registry.register
+class DefaultEmptyImagePlaceholderPreference(StringPreference):
+    section = wbcore_section
+    name = "default_empty_image_placeholder"
+    default = "https://stainly-cdn.fra1.cdn.digitaloceanspaces.com/icons/empty_image_placeholder.png"
+
+    verbose_name = _("Default Empty Image Placeholder")
+    help_text = _("Default empty image placeholder URL")

wbcore/markdown/models.py

@@ -0,0 +1,41 @@
+import mimetypes
+import pathlib
+import uuid
+
+from django.db import models
+from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
+
+
+def upload_to(instance, filename):
+    return f"markdown/assets/{instance.filename}"
+
+
+class Asset(models.Model):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+
+    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):
+        if suffix := pathlib.Path(self.file.name).suffix:
+            return f"{self.id}{suffix}"
+        return self.id
+
+
+@receiver(models.signals.pre_save, sender="wbcore.Asset")
+def generate_content_type(sender, instance, **kwargs):
+    content_type, encoding = mimetypes.guess_type(pathlib.Path(instance.file.name))
+    instance.content_type = content_type
+    instance.file_url_name = instance.filename

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,37 @@
+import re
+
+from dynamic_preferences.registries import global_preferences_registry
+from weasyprint import default_url_fetcher
+
+from wbcore.markdown.models import Asset
+
+
+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,50 @@
+from django.core.exceptions import ValidationError
+from django.http import HttpResponse
+from django.template import exceptions
+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 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, AttributeError):
+            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 Any, 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: Callable | Dict[str, Any] = 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,60 @@
+from typing import Iterable
+
+from django.contrib.messages.storage.base import BaseStorage, Message
+from django.contrib.messages.storage.fallback import FallbackStorage
+from rest_framework_simplejwt.settings import api_settings
+
+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,
+            }
+
+
+def route_message_storage(request):
+    # This is a simple hack to detect when the request is initiated by our frontend client or by a session based page (e.g. Admin)
+    if request.META.get(api_settings.AUTH_HEADER_NAME):
+        return InMemoryMessageStorage(request)
+    return FallbackStorage(request)