wbcore 2.2.1__py2.py3-none-any.whl

wbcore/permissions/backend.py

@@ -0,0 +1,35 @@
+from contextlib import suppress
+
+from django.contrib.auth.models import Group, Permission
+from django.db.models import Q, QuerySet
+from django.utils.functional import cached_property
+from guardian.utils import get_anonymous_user
+from wbcore.contrib.authentication.models.users import User
+
+
+class UserBackend:
+    """
+    Base UserBackend for basic support (default to all valid user except the anonymous user)
+    """
+
+    @cached_property
+    def internal_user_permission(self) -> Permission | None:
+        try:
+            return Permission.objects.get(content_type__app_label="authentication", codename="is_internal_user")
+        except Permission.DoesNotExist:
+            return None
+
+    def get_internal_groups(self) -> QuerySet[Group]:
+        if self.internal_user_permission:
+            return Group.objects.filter(permissions=self.internal_user_permission)
+        return Group.objects.none()
+
+    def get_internal_users(self) -> QuerySet[User]:
+        if self.internal_user_permission:
+            qs = User.objects.filter(is_active=True).filter(
+                Q(user_permissions=self.internal_user_permission) | Q(groups__in=self.get_internal_groups().all())
+            )
+            with suppress(User.DoesNotExist):
+                qs = qs.exclude(id=get_anonymous_user().id)
+            return qs.distinct()
+        return User.objects.none()

wbcore/permissions/mixins.py

@@ -0,0 +1,72 @@
+from django.db import models
+
+
+class PermissionMixin(models.Model):
+    class Meta:
+        abstract = True
+
+    @classmethod
+    @property
+    def view_perm_str(cls) -> str:
+        """
+        Get the view string permission identifer
+
+        Returns:
+            The view string permission identifier
+        """
+        return f"{cls._meta.app_label}.view_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def change_perm_str(cls) -> str:
+        """
+        Get the change string permission identifer
+
+        Returns:
+            The change string permission identifier
+        """
+        return f"{cls._meta.app_label}.change_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def delete_perm_str(cls) -> str:
+        """
+        Get the delete string permission identifer
+
+        Returns:
+            The delete string permission identifier
+        """
+        return f"{cls._meta.app_label}.delete_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def select_perm_str(cls) -> str:
+        """
+        Get the select string permission identifer
+
+        Returns:
+            The select string permission identifier
+        """
+        return f"{cls._meta.app_label}.select_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def admin_perm_str(cls) -> str:
+        """
+        Get the admin string permission identifer
+
+        Returns:
+            The admin string permission identifier
+        """
+        return f"{cls._meta.app_label}.administrate_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def add_perm_str(cls) -> str:
+        """
+        Get the add string permission identifer
+
+        Returns:
+            The add string permission identifier
+        """
+        return f"{cls._meta.app_label}.add_{cls._meta.model_name}"

wbcore/permissions/permissions.py

@@ -0,0 +1,50 @@
+from rest_framework import permissions
+from rest_framework.permissions import BasePermission
+from wbcore.enums import WidgetType
+
+from .shortcuts import is_internal_user
+
+
+class RestAPIModelPermissions(permissions.DjangoModelPermissions):
+    """
+    Mixin for adding the view permission to the perms_map
+    NOTE: This is only here until Django Rest Framework patches
+    their DjangoModelPermissions to include view permissions
+    """
+
+    perms_map = {
+        "GET": ["%(app_label)s.view_%(model_name)s"],
+        "OPTIONS": ["%(app_label)s.select_%(model_name)s"],
+        "SELECT": ["%(app_label)s.select_%(model_name)s"],
+        "HEAD": ["%(app_label)s.select_%(model_name)s"],
+        "POST": ["%(app_label)s.add_%(model_name)s"],
+        "PUT": ["%(app_label)s.change_%(model_name)s"],
+        "PATCH": ["%(app_label)s.change_%(model_name)s"],
+        "DELETE": ["%(app_label)s.delete_%(model_name)s"],
+    }
+
+    def has_permission(self, request, view):
+        method = request.method
+        if getattr(view, "WIDGET_TYPE", None) == WidgetType.SELECT.value:
+            method = "SELECT"
+        if getattr(view, "_ignore_model_permissions", False):
+            return True
+
+        if not request.user or (not request.user.is_authenticated and self.authenticated_users_only):
+            return False
+
+        queryset = self._queryset(view)
+        perms = self.get_required_permissions(method, queryset.model)
+
+        return request.user.has_perms(perms)
+
+
+class IsInternalUser(BasePermission):
+    def has_permission(self, request, view) -> bool:
+        return is_internal_user(request.user, True)
+
+
+class InternalUserPermissionMixin:
+    def get_permissions(self):
+        permissions = super().get_permissions()  # type: ignore
+        return [*permissions, IsInternalUser()]

wbcore/permissions/registry.py

@@ -0,0 +1,32 @@
+from contextlib import suppress
+
+from django.conf import settings
+from django.contrib.auth.models import Group
+from django.db.models import QuerySet
+from django.utils.functional import cached_property
+from wbcore.contrib.authentication.models import User
+from wbcore.utils.importlib import import_from_dotted_path
+
+
+class UserBackendRegistry:
+    def __init__(self):
+        internal_users_backend_path = getattr(settings, "USER_BACKEND", "wbcore.permissions.backend.UserBackend")
+        internal_users_backend_class = import_from_dotted_path(internal_users_backend_path)
+        self.backend = internal_users_backend_class()
+
+    @cached_property
+    def internal_groups(self) -> QuerySet[Group]:
+        return self.backend.get_internal_groups().all()
+
+    @cached_property
+    def internal_users(self) -> QuerySet[User]:
+        return self.backend.get_internal_users().all()
+
+    def reset_cache(self):
+        with suppress(AttributeError):
+            del self.internal_users
+        with suppress(AttributeError):
+            del self.internal_groups
+
+
+user_registry = UserBackendRegistry()

wbcore/permissions/shortcuts.py

@@ -0,0 +1,37 @@
+from django.contrib.auth.models import Group
+from django.db.models.query import QuerySet
+from wbcore.contrib.authentication.models.users import User
+
+
+def get_internal_groups() -> QuerySet[Group]:
+    from wbcore.permissions.registry import user_registry
+
+    """
+    Return the cached groups of internals users
+
+    Returns:
+        A queryset of group corresponding to the internal notion defined by the set UserBackend
+
+    Raises:
+        ValueError: If user backend path does not correspond to a valid module
+    """
+    return user_registry.internal_groups
+
+
+def get_internal_users() -> QuerySet[User]:
+    from wbcore.permissions.registry import user_registry
+
+    """
+    Return the cached queryset of internals users
+
+    Returns:
+        A queryset of user corresponding to the internal notion defined by the set UserBackend
+
+    Raises:
+        ValueError: If user backend path does not correspond to a valid module
+    """
+    return user_registry.internal_users
+
+
+def is_internal_user(user: User, include_superuser: bool = False) -> bool:
+    return user and (user.is_internal or (include_superuser and user.is_superuser))

wbcore/permissions/utils.py

@@ -0,0 +1,26 @@
+from django.contrib.auth.models import Permission
+
+
+def perm_to_permission(perm: str) -> Permission:
+    """
+    Convert a identifier string permission format in 'app_label.codename'
+    (teremd as *perm*) to a django permission instance.
+
+    Args:
+        perm: The string permission identifier in the form 'app_label.codename'
+
+    Returns:
+        The Permission object corresponding to the given string identifier
+
+    Raises:
+        AttributeError: When the given string identifier does not match the expected format 'app_label.codename'
+    """
+    try:
+        app_label, codename = perm.split(".", 1)
+    except IndexError:
+        raise AttributeError(
+            "The format of identifier string permission (perm) is wrong. " "It should be in 'app_label.codename'."
+        )
+    else:
+        permission = Permission.objects.get(content_type__app_label=app_label, codename=codename)
+        return permission

wbcore/release_notes/admin.py

@@ -0,0 +1,30 @@
+from django.contrib import admin
+from django.utils.html import format_html
+
+from .models import ReleaseNote
+
+
+@admin.register(ReleaseNote)
+class ReleaseNoteModelAdmin(admin.ModelAdmin):
+    list_display = (
+        "version",
+        "release_date",
+        "summary",
+        "module",
+    )
+    list_filter = ("module", "release_date")
+
+    fields = (("version", "module", "release_date"), "summary", "rendered_notes")
+
+    @staticmethod
+    def rendered_notes(obj):
+        return format_html(obj.notes)
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        return False

wbcore/release_notes/buttons.py

@@ -0,0 +1,25 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class ReleaseNotesButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self):
+        if not self.view.kwargs.get("pk", None):
+            return {
+                bt.ActionButton(
+                    method=RequestType.PATCH,
+                    action_label=_("Reading all release notes"),
+                    endpoint=reverse("wbcore:releasenote-mark-all-as-read", request=self.request),
+                    description_fields=_("Do you want to mark all release notes as read?"),
+                    label=_("Mark all as read"),
+                    icon=WBIcon.VIEW.icon,
+                    confirm_config=bt.ButtonConfig(label=_("Read all")),
+                    cancel_config=bt.ButtonConfig(label=_("Cancel")),
+                    identifiers=("wbcore:releasenote",),
+                ),
+            }
+        return dict()

wbcore/release_notes/display.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class ReleaseNoteDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="module", label=_("Module")),
+                dp.Field(key="version", label=_("Version")),
+                dp.Field(key="release_date", label=_("Release Date")),
+                dp.Field(key="summary", label=_("Summary")),
+            ],
+            formatting=[
+                dp.Formatting(
+                    column="user_read",
+                    formatting_rules=[
+                        dp.FormattingRule(icon=WBIcon.VIEW.icon, condition=("==", True)),
+                    ],
+                ),
+            ],
+            legends=[
+                dp.Legend(
+                    key="read_unread",
+                    items=[
+                        dp.LegendItem(
+                            icon=WBIcon.VIEW.icon,
+                            label=_("Read"),
+                            value="read",
+                        ),
+                        dp.LegendItem(
+                            icon=WBIcon.IGNORE.icon,
+                            label=_("Unread"),
+                            value="unread",
+                        ),
+                    ],
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["module", "version", "release_date"],
+                [repeat_field(3, "summary")],
+                [repeat_field(3, "notes")],
+            ]
+        )

wbcore/release_notes/filters.py

@@ -0,0 +1,35 @@
+from django.utils.translation import gettext_lazy as _
+from wbcore import filters
+
+from .models import ReleaseNote
+
+
+def get_choices(*args):
+    choices = [(rl, rl) for rl in ReleaseNote.objects.all().distinct("module").values_list("module", flat=True)]
+    return choices
+
+
+class ReleaseNoteFilterSet(filters.FilterSet):
+    module = filters.ChoiceFilter(label=_("Module"), choices=get_choices)
+
+    read_unread = filters.ChoiceFilter(
+        label=_("Read / Unread"),
+        choices=(("read", "Read"), ("unread", "Unread")),
+        method="get_read_unread",
+    )
+
+    def get_read_unread(self, queryset, name, value):
+        if value == "read":
+            return queryset.filter(user_read=True)
+        elif value == "unread":
+            return queryset.filter(user_read=False)
+        return queryset
+
+    class Meta:
+        model = ReleaseNote
+        fields = {
+            "version": ["icontains"],
+            "module": ["exact"],
+            "release_date": ["exact", "lte", "gte"],
+            "summary": ["icontains"],
+        }

wbcore/release_notes/models.py

@@ -0,0 +1,65 @@
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from wbcore.release_notes.utils import parse_release_note
+
+
+class ReleaseNote(models.Model):
+    """
+    This model holds all relevant information about a new release. Instances of this model will never be created
+    manually, but always through a management command that manages them from markdown files. Those markdown files
+    sit in a dedicated folder called `release_notes`. There are two exceptions for this:
+    - The release notes of wbcore: `wbcore/release_notes/release_notes`
+    - The release notes of the frontend: `wbcore/release_notes/frontend_release_notes`
+
+    The markdown files have to abide by a certain format, which includes metadata from which all fields are filled.
+    The markdown content is parsed through python-markdown and is saved as html. With every deployment, the
+    management command `handle_release_notes` is called.
+    """
+
+    version = models.CharField(max_length=18, help_text=_("The version/identifier of the release"))
+    release_date = models.DateField(help_text=_("The date when this new version was released"))
+    module = models.CharField(max_length=255, help_text=_("The workbench module of the release"))
+    summary = models.CharField(max_length=512, help_text=_("A brief summary of the release"))
+    notes = models.TextField(default="", help_text=_("What's new? What's improved? What's fixed?"))
+    read_by = models.ManyToManyField(
+        to=get_user_model(), related_name="read_patch_notes", db_table="bridger_releasenote_read_by"
+    )
+
+    @classmethod
+    def handle_from_markdown(cls, markdown_content: str) -> "ReleaseNote":
+        content, meta, version, module, summary, release_date = parse_release_note(markdown_content)
+
+        try:
+            release_note = cls.objects.get(version=version, module=module)
+            release_note.summary = summary
+            release_note.release_date = release_date
+            release_note.notes = content
+            release_note.save()
+        except cls.DoesNotExist:
+            release_note = cls.objects.create(
+                version=version,
+                module=module,
+                release_date=release_date,
+                summary=summary,
+                notes=content,
+            )
+
+        return release_note
+
+    def __str__(self) -> str:
+        return f"{self.module}: {self.version}"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:releasenote"
+
+    class Meta:
+        verbose_name = _("Release Note")
+        verbose_name_plural = _("Release Notes")
+
+        constraints = [
+            models.UniqueConstraint(fields=["version", "module"], name="release_note_unique_version_module")
+        ]
+
+        db_table = "bridger_releasenote"

wbcore/release_notes/serializers.py

@@ -0,0 +1,19 @@
+from wbcore import serializers
+
+from .models import ReleaseNote
+
+
+class ReleaseNoteModelSerializer(serializers.ModelSerializer):
+    user_read = serializers.BooleanField()
+
+    class Meta:
+        model = ReleaseNote
+        fields = (
+            "id",
+            "version",
+            "release_date",
+            "module",
+            "summary",
+            "notes",
+            "user_read",
+        )

wbcore/release_notes/utils.py

@@ -0,0 +1,14 @@
+from datetime import datetime
+
+from markdown import Markdown
+
+
+def parse_release_note(release_note):
+    md = Markdown(extensions=["meta"], tab_length=2)
+    content = md.convert(release_note)
+    meta = md.Meta
+    version = meta["version"][0]
+    module = meta["module"][0]
+    summary = meta["summary"][0]
+    release_date = datetime.strptime(meta["date"][0], "%Y-%m-%d")
+    return content, meta, version, module, summary, release_date

wbcore/release_notes/viewsets.py

@@ -0,0 +1,45 @@
+from django.db.models import Exists, OuterRef, Q
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+
+from .buttons import ReleaseNotesButtonConfig
+from .display import ReleaseNoteDisplayConfig
+from .filters import ReleaseNoteFilterSet
+from .models import ReleaseNote
+from .serializers import ReleaseNoteModelSerializer
+
+
+class ReleaseNoteReadOnlyModelViewSet(viewsets.ReadOnlyModelViewSet):
+    display_config_class = ReleaseNoteDisplayConfig
+    button_config_class = ReleaseNotesButtonConfig
+
+    queryset = ReleaseNote.objects.all()
+    serializer_class = ReleaseNoteModelSerializer
+    filterset_class = ReleaseNoteFilterSet
+    search_fields = ("module", "version", "summary")
+    ordering_fields = ("module", "version", "release_date")
+    ordering = ("-release_date", "-version")
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(user_read=Exists(ReleaseNote.objects.filter(id=OuterRef("id"), read_by=self.request.user)))
+        )
+
+    def retrieve(self, request, *args, **kwargs):
+        obj = self.get_object()
+        if not obj.read_by.filter(id=self.request.user.id).exists():
+            obj.read_by.add(self.request.user)
+        return super().retrieve(request, *args, **kwargs)
+
+    @action(methods=["GET"], detail=False)
+    def unread_count(self, request, pk=None):
+        return Response({"count": ReleaseNote.objects.filter(~Q(read_by=self.request.user)).count()})
+
+    @action(methods=["PATCH"], detail=False)
+    def mark_all_as_read(self, request, pk=None):
+        for rl in ReleaseNote.objects.filter(~Q(read_by=self.request.user)):
+            rl.read_by.add(self.request.user)
+        return Response({})

wbcore/reversion/filters.py

@@ -0,0 +1,38 @@
+from reversion.models import Revision, Version
+from wbcore import filters as wb_filters
+
+
+class RevisionFilterSet(wb_filters.FilterSet):
+    user = wb_filters.ModelChoiceFilter(
+        queryset=Revision.objects.all(),
+        endpoint="wbcore:revisionrepresentation-list",
+        value_key="id",
+        label_key="{{user}} - {{date_created}}",
+    )
+    profile = wb_filters.NumberFilter(method="filter_profile")
+
+    def filter_profile(self, queryset, name, value):
+        return queryset.filter(user__profile=value)
+
+    class Meta:
+        model = Revision
+        fields = {"date_created": ["gte", "exact", "lte"]}
+
+
+class VersionFilterSet(wb_filters.FilterSet):
+    content_type = wb_filters.NumberFilter(method="filter_content_type")
+    exclude_id = wb_filters.NumberFilter(method="filter_exclude_id")
+
+    def filter_content_type(self, queryset, name, value):
+        if value:
+            return queryset.filter(content_type=value)
+        return queryset
+
+    def filter_exclude_id(self, queryset, name, value):
+        if value:
+            return queryset.exclude(id=value)
+        return queryset
+
+    class Meta:
+        model = Version
+        fields = {"content_type": ["exact"], "object_id": ["exact"]}

wbcore/reversion/serializers.py

@@ -0,0 +1,80 @@
+from rest_framework.reverse import reverse
+from reversion.models import Revision, Version
+from wbcore import serializers
+from wbcore import serializers as wb_serializers
+
+
+class RevisionRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbcore:revision-detail")
+
+    endpoint = "wbcore:revisionrepresentation-list"
+    value_key = "id"
+    label_key = "{{date_created}}"
+
+    class Meta:
+        model = Revision
+        fields = ("id", "date_created", "_detail")
+
+
+class VersionRepresentationSerializer(serializers.RepresentationSerializer):
+    _detail = serializers.HyperlinkField(reverse_name="wbcore:version-detail")
+    user_repr = serializers.StringRelatedField(source="revision.user")
+    revision_date_created = serializers.StringRelatedField(source="revision.date_created")
+
+    endpoint = "wbcore:versionrepresentation-list"
+    value_key = "id"
+    label_key = "{{id}} - {{user_repr}} - {{revision_date_created}}"
+
+    class Meta:
+        model = Version
+        fields = ("id", "user_repr", "revision_date_created", "_detail")
+
+
+class RevisionModelSerializer(serializers.ModelSerializer):
+    user_repr = serializers.StringRelatedField(read_only=True, source="user")
+    user = serializers.IntegerField(read_only=True, source="user.id")
+    # @wb_serializers.register_resource()
+    # def versions(self, instance, request, user):
+    #     return {"versions": reverse("wbcore:revision-version-list", args=[instance.id], request=request)}
+
+    class Meta:
+        model = Revision
+        fields = read_only_fields = (
+            "id",
+            "date_created",
+            "user_repr",
+            "user",
+            "comment",
+            "_additional_resources",
+        )
+
+
+class VersionModelSerializer(serializers.ModelSerializer):
+    date_created = serializers.DateTimeField(read_only=True, source="revision.date_created")
+    _revision = RevisionRepresentationSerializer(source="revision")
+    profile_repr = serializers.CharField(read_only=True)
+
+    object_repr = serializers.CharField()
+
+    @wb_serializers.register_resource()
+    def resources(self, instance, request, user):
+        res = {"compare_with": reverse("wbcore:version-comparewith", args=[instance.id], request=request)}
+        if user.has_perm("reversion.change_version") or user.is_superuser:
+            res["revert"] = reverse("wbcore:version-revert", args=[instance.id], request=request)
+        return res
+
+    class Meta:
+        model = Version
+        fields = read_only_fields = (
+            "id",
+            "profile_repr",
+            "revision",
+            "_revision",
+            "content_type",
+            "object_id",
+            "object_repr",
+            "serialized_data",
+            "date_created",
+            "_additional_resources",
+            # "field_dict"
+        )