wbcore 2.2.1__py2.py3-none-any.whl

wbcore/forms.py

@@ -0,0 +1,125 @@
+import ast
+from urllib.parse import unquote
+
+from django import forms
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ValidationError
+from django.forms import modelformset_factory
+from django.forms.models import BaseModelFormSet
+from psycopg.types.range import DateRange, TimestamptzRange
+
+
+class NonrelatedInlineFormSet(BaseModelFormSet):
+    """
+    A basic implementation of an inline formset that doesn't make assumptions
+    about any relationship between the form model and its parent instance.
+    """
+
+    def __init__(self, instance=None, save_as_new=None, **kwargs):
+        self.instance = instance
+        super().__init__(**kwargs)
+        self.queryset = self.real_queryset
+
+    @classmethod
+    def get_default_prefix(cls):
+        opts = cls.model._meta
+        return opts.app_label + "-" + opts.model_name
+
+    def save_new(self, form, commit=True):
+        obj = super().save_new(form, commit=False)
+        self.save_new_instance(self.instance, obj)
+        if commit:
+            obj.save()
+        return obj
+
+
+def nonrelated_inlineformset_factory(
+    model, obj=None, queryset=None, formset=NonrelatedInlineFormSet, save_new_instance=None, **kwargs
+):
+    """
+    FormSet factory that sets an explicit queryset on new classes.
+    """
+    FormSet = modelformset_factory(model, formset=formset, **kwargs)
+    FormSet.real_queryset = queryset
+    FormSet.save_new_instance = save_new_instance
+    return FormSet
+
+
+class ContentTypeMultiValueField(forms.fields.MultiValueField):
+    def __init__(self, fields=None, *args, **kwargs):
+        if fields is None:
+            fields = (forms.IntegerField(), forms.IntegerField())
+        super().__init__(fields, *args, **kwargs)
+
+    def clean(self, value):
+        value = self.to_python(value)
+        res = []
+        for val in value:
+            res.append(super().clean(val))
+        return res
+
+    def to_python(self, value):
+        if value:
+            return ast.literal_eval(value)
+        return []
+
+    def compress(self, data_list):
+        content_type_id, object_id = data_list
+        try:
+            content_type = ContentType.objects.get_for_id(content_type_id)
+            return content_type.get_object_for_this_type(id=object_id)
+        except (ContentType.DoesNotExist, content_type.model_class().DoesNotExist):
+            return None
+
+
+class TupleWidget(forms.TextInput):
+    """
+    Format a input of the form "param=val1,val2"
+    """
+
+    def value_from_datadict(self, data, files, name):
+        if res := data.get(name, None):
+            return unquote(res).split(",")
+
+
+class DateRangeField(forms.MultiValueField):
+    """
+    A date range
+    """
+
+    default_error_messages = {
+        "invalid": "Enter a valid date range.",
+    }
+    widget = TupleWidget
+    form_date_field = forms.DateField
+    python_field = DateRange
+
+    def validate(self, value):
+        if value.lower and value.upper and value.upper < value.lower:
+            raise ValidationError(
+                self.error_messages["invalid"],
+                code="invalid_choice",
+            )
+
+    def __init__(self, **kwargs):
+        fields = (
+            self.form_date_field(required=True),
+            self.form_date_field(required=True),
+        )
+        super().__init__(fields, **kwargs)
+
+    def compress(self, values):
+        try:
+            lower, upper = values
+            return self.python_field(lower=lower, upper=upper)
+        except ValueError:
+            return None
+
+
+class DateTimeRangeField(DateRangeField):
+    """
+    A date time range
+    """
+
+    form_date_field = forms.DateTimeField
+    python_field = TimestamptzRange

wbcore/frontend.py

@@ -0,0 +1,23 @@
+from copy import copy
+
+from django.conf import settings
+from django.urls import path
+from django.views.generic import TemplateView
+
+
+class FrontendView(TemplateView):
+    template_name = settings.FRONTEND_TEMPLATE
+
+    def get_context_data(self, **kwargs):
+        context = {**super().get_context_data(**kwargs), **copy(settings.FRONTEND_CONTEXT)}
+        if version := self.request.GET.get("frontend_version", None):
+            base_url = f"{settings.CDN_BASE_ENDPOINT_URL}/{version}/"
+            context["JS_RUNTIME_URL"] = f"{base_url}runtime.js"
+            context["JS_URL"] = f"{base_url}main.js"
+            context["CSS_URL"] = f"{base_url}main.css"
+        context["WBCORE_CONTEXT"] = context
+        return context
+
+    @classmethod
+    def bundled_view(cls, url_path):
+        return path(route=url_path, view=cls.as_view(), name="frontend")

wbcore/frontend_user_configuration.py

@@ -0,0 +1,96 @@
+import logging
+import uuid
+
+import django_filters
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import OrderingFilter
+
+from .filters import BooleanFilter, CharFilter, ModelChoiceFilter
+from .serializers import ModelSerializer, PrimaryKeyCharField
+from .viewsets import InfiniteDataModelView
+
+logger = logging.getLogger(__name__)
+
+
+class FrontendUserConfiguration(models.Model):
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    user = models.ForeignKey(to=get_user_model(), related_name="configurations", on_delete=models.CASCADE)
+
+    parent_configuration = models.ForeignKey(
+        to="self",
+        related_name="child_configurations",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+    )
+    config = models.JSONField(default=dict, null=True, blank=True)
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:frontenduserconfiguration"
+
+    def __str__(self):
+        return f"{self.id}"
+
+    class Meta:
+        verbose_name = _("Frontend User Settings")
+        verbose_name_plural = _("Frontend User Settings")
+
+        db_table = "bridger_frontenduserconfiguration"
+
+
+class FrontendUserConfigurationModelSerializer(ModelSerializer):
+    id = PrimaryKeyCharField()
+
+    def validate(self, data):
+        if request := self.context.get("request"):
+            data["user"] = request.user
+        return super().validate(data)
+
+    class Meta:
+        model = FrontendUserConfiguration
+        fields = ["id", "parent_configuration", "config"]
+
+
+class FrontendUserConfigurationFilterSet(django_filters.rest_framework.FilterSet):
+    is_root = BooleanFilter(label=_("Is Root"), method="get_is_root")
+    parent_configuration = ModelChoiceFilter(
+        label=_("Parent Configuration"), queryset=FrontendUserConfiguration.objects.all()
+    )
+    config = CharFilter(label=_("Config"), method="filter_config")
+
+    def get_is_root(self, queryset, name, value):
+        return queryset.filter(parent_configuration__isnull=value)
+
+    def filter_config(self, queryset, name, value):
+        try:
+            key, value = value.split(":")
+            if value in ["true", "false"]:
+                value = True if value == "true" else False
+            return queryset.filter(**{f"config__{key}": value})
+        except ValueError:
+            return queryset
+
+    class Meta:
+        model = FrontendUserConfiguration
+        fields = ["is_root", "config"]
+
+
+class FrontendUserConfigurationModelViewSet(InfiniteDataModelView):
+    serializer_class = FrontendUserConfigurationModelSerializer
+    filter_backends = [OrderingFilter, DjangoFilterBackend]
+    filterset_class = FrontendUserConfigurationFilterSet
+
+    ordering_fields = ordering = [
+        "id",
+        *settings.WBCORE_DEFAULT_FRONTEND_USER_CONFIGURATION_ORDER,
+    ]
+
+    queryset = FrontendUserConfiguration.objects.none()
+
+    def get_queryset(self):
+        return FrontendUserConfiguration.objects.filter(user=self.request.user)

wbcore/fsm/markdown_extensions.py

@@ -0,0 +1,31 @@
+from django.apps import apps
+from markdown.extensions import Extension
+from markdown.preprocessors import Preprocessor
+
+
+class FSMPreprocessor(Preprocessor):
+    def __init__(self, *args, **kwargs):
+        self.indicator = "!!!wbcore-fsm"
+        super().__init__(*args, **kwargs)
+
+    def run(self, lines):
+        for line in lines:
+            if self.indicator in line:
+                _, app_model, model_field = line.split(":")
+                model = apps.get_model(app_model)
+
+                yield "~~~mermaid\ngraph TD"
+
+                transitions = getattr(model(), f"get_all_{model_field}_transitions")
+                for transition in transitions():
+                    yield f"\t({transition.source}) --> |{transition.name}|({transition.target})"
+
+                yield "~~~"
+
+            else:
+                yield line
+
+
+class FSMExtension(Extension):
+    def extendMarkdown(self, md, md_globals):
+        md.preprocessors.register(FSMPreprocessor(), "wbcore-fsm", 100)

wbcore/fsm/mixins.py

@@ -0,0 +1,114 @@
+import logging
+
+from django_fsm import FSMField, Transition, TransitionNotAllowed
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.request import Request
+from rest_framework.response import Response
+
+logger = logging.getLogger(__name__)
+
+
+# We have to move the method generation into a method, because we need a real new instance of this method everytime
+def get_method(transition, fsm_field_name):
+    def method(self, request: Request, transition=transition, pk=None, **kwargs) -> Response:
+        return self.fsm_route(request, transition, fsm_field_name, transition.custom.get("serializer", None))
+
+    return method
+
+
+class FSMViewSetMixinMetaclass(type):
+    """Metaclass for dynamically creating all FSM Routes"""
+
+    def __new__(cls, name, bases, dct):
+        _class = super().__new__(cls, name, bases, dct)
+
+        # The class needs the field FSM_MODELFIELDS to know which transitions it needs to add
+        if hasattr(_class, "get_model"):
+            model = _class.get_model()
+
+            if model:
+                setattr(_class, "FSM_BUTTONS", getattr(_class, "FSM_BUTTONS", set()))
+                # The model potentially has multiple FSMFields, which needs to be iterated over
+                for field in filter(lambda f: isinstance(f, FSMField), model._meta.fields):
+                    # Get all transitions, by calling the partialmethod defined by django-fsm
+                    transitions = getattr(model, f"get_all_{field.name}_transitions")(model())
+
+                    # Since the method above can potentially return a transition multiple times
+                    # i.e. when a transitions has multiple sources, we need to filter out those transitions
+                    _discovered_transitions = list()
+
+                    for transition in transitions:
+                        if transition.name in _discovered_transitions:
+                            continue
+                        else:
+                            _discovered_transitions.append(transition.name)
+
+                        # Get the Transition Button and add it to the front of the instance buttons
+                        button = transition.custom.get("_transition_button")
+                        _class.FSM_BUTTONS.add(button)
+
+                        # Create a method that calls fsm_route with the request and the action name
+                        method = get_method(transition, field.name)
+
+                        # We need to manually change the method name, otherwise django-fsm won't
+                        # Add this method to the URLs
+
+                        # Wrap the above defined method in the action decorator
+                        # IMPORTANT: This needs to happen after we changed the method name
+                        # therefore we cannot use the proper decorator
+                        method.__name__ = transition.name
+                        method.__doc__ = transition.method.__doc__
+
+                        wrapped_method = action(detail=True, methods=["GET", "PATCH"])(method)
+
+                        # Set the method as a attribute of the class that implements this
+                        # metaclass
+                        setattr(_class, transition.name, wrapped_method)
+
+        return _class
+
+
+class FSMViewSetMixin(metaclass=FSMViewSetMixinMetaclass):
+    def handle_exception(self, exc: Exception) -> Response:
+        if isinstance(exc, TransitionNotAllowed):
+            return Response({"non_field_errors": str(exc)}, status=status.HTTP_400_BAD_REQUEST)
+        return super().handle_exception(exc)
+
+    def fsm_route(
+        self, request: Request, transition: Transition, fsm_field_name: str, serializer_class=None
+    ) -> Response:
+        action = transition.name
+        obj = self.get_object()
+
+        if not serializer_class:
+            serializer_class = self.get_serializer_class()
+        serializer_context = self.get_serializer_context()
+
+        if request.method == "GET":
+            return Response(serializer_class(instance=obj, context=serializer_context).data)
+
+        serializer = serializer_class(instance=obj, data=request.data, partial=True, context=serializer_context)
+        if serializer.is_valid():
+            if len(serializer.validated_data) > 0:
+                obj = serializer.save()
+        else:
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        errors = None
+        if (can_action_method := getattr(obj, f"can_{action}", None)) and callable(can_action_method):
+            errors = can_action_method()
+
+        if errors is None or len(errors.keys()) == 0:
+            obj.fsm_context = {"current_user": request.user}
+            if getattr(obj, fsm_field_name) != transition.target:
+                if (action_method := getattr(obj, action, None)) and callable(action_method):
+                    action_method(by=request.user)
+                    obj.save()
+                    if (post_action_method := getattr(obj, f"post_{action}", None)) and callable(post_action_method):
+                        post_action_method(by=request.user)
+
+            serializer = serializer_class(instance=obj, context=serializer_context)
+            return Response({"instance": serializer.data})
+
+        return Response(errors, status=status.HTTP_412_PRECONDITION_FAILED)

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,53 @@
+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,38 @@
+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)
+
+    @property
+    def filename(self):
+        if suffix := pathlib.Path(self.file.name).suffix:
+            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):
+    content_type, encoding = mimetypes.guess_type(pathlib.Path(instance.file.name))
+    instance.content_type = content_type
+    instance.file_url_name = instance.filename