wbcore 1.59.9__py2.py3-none-any.whl

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,26 @@
+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,52 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import Unit
+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="user_read_icon", label=" ", width=Unit.PIXEL(40)),
+                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")),
+            ],
+            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,36 @@
+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,66 @@
+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,12 @@
+from wbcore import serializers
+
+from .models import ReleaseNote
+
+
+class ReleaseNoteModelSerializer(serializers.ModelSerializer):
+    user_read = serializers.BooleanField()
+    user_read_icon = serializers.IconSelectField()
+
+    class Meta:
+        model = ReleaseNote
+        fields = ("id", "version", "release_date", "module", "summary", "notes", "user_read", "user_read_icon")

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,52 @@
+from django.db.models import Case, Exists, OuterRef, Q, Value, When
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from wbcore import viewsets
+
+from ..contrib.icons import WBIcon
+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)),
+                user_read_icon=Case(
+                    When(user_read=True, then=Value(WBIcon.VIEW.icon)), default=Value(WBIcon.IGNORE.icon)
+                ),
+            )
+        )
+
+    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,39 @@
+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,81 @@
+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"
+        )

wbcore/reversion/viewsets/__init__.py

@@ -0,0 +1,6 @@
+from .displays import RevisionDisplayConfig, VersionDisplayConfig
+from .endpoints import (
+    RevisionEndpointConfig,
+    VersionEndpointConfig,
+    VersionRevisionEndpointConfig,
+)

wbcore/reversion/viewsets/buttons.py

@@ -0,0 +1,95 @@
+from django.contrib.contenttypes.models import ContentType
+from django.dispatch import receiver
+from django.utils.translation import gettext as _
+from django.utils.translation import gettext_lazy
+from rest_framework.reverse import reverse
+from reversion import is_registered
+from reversion.models import Version
+
+from wbcore import serializers
+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
+from wbcore.metadata.configs.display.instance_display import create_simple_display
+from wbcore.signals.instance_buttons import add_extra_button
+
+from ..serializers import VersionRepresentationSerializer
+
+
+class VersionButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self):
+        if self.request.user.is_staff or self.request.user.is_superuser:
+            if (content_type_id := self.view.request.GET.get("content_type", None)) and (
+                object_id := self.view.request.GET.get("object_id", None)
+            ):
+                content_type = ContentType.objects.get(id=content_type_id)
+                return {
+                    bt.HyperlinkButton(
+                        label=_("Compare in Admin"),
+                        endpoint=f"/admin/{content_type.app_label}/{content_type.model}/{object_id}/history/",
+                    )
+                }
+        return set()
+
+    def get_custom_list_instance_buttons(self):
+        if (content_type_id := self.view.request.GET.get("content_type", None)) and (
+            object_id := self.view.request.GET.get("object_id", None)
+        ):
+            content_type = ContentType.objects.get(id=content_type_id)
+            obj = content_type.model_class().objects.get(id=object_id)
+
+            class CompareSerializer(serializers.Serializer):
+                compare_with = serializers.PrimaryKeyRelatedField(
+                    label=gettext_lazy("Start"), queryset=Version.objects.get_for_object(obj)
+                )
+                _compare_with = VersionRepresentationSerializer(
+                    source="compare_with", filter_params={"content_type": content_type_id, "object_id": object_id}
+                )
+
+            return {
+                bt.ActionButton(
+                    method=RequestType.GET,
+                    identifiers=("{0.app_label}:{0.model}".format(content_type),),
+                    key="revert",
+                    label=_("Revert"),
+                    icon=WBIcon.SYNCHRONIZE.icon,
+                    description_fields=_(
+                        """
+                    <p>Revert object to this version</p>
+                    """
+                    ),
+                    action_label=_("Reverting"),
+                    title=_("Revert"),
+                ),
+                bt.ActionButton(
+                    method=RequestType.GET,
+                    identifiers=("wbcore:version",),
+                    key="compare_with",
+                    label=_("Compare With"),
+                    icon=WBIcon.DATA_GRID.icon,
+                    description_fields=_(
+                        """
+                    <p>Compare this version with another version</p>
+                    """
+                    ),
+                    serializer=CompareSerializer,
+                    action_label=_("Comparing"),
+                    title=_("Compare With"),
+                    instance_display=create_simple_display([["compare_with"]]),
+                ),
+            }
+        return set()
+
+    def get_custom_instance_buttons(self):
+        return self.get_custom_list_instance_buttons()
+
+
+@receiver(add_extra_button)
+def add_reversion_documents(sender, instance, request, view, pk=None, **kwargs):
+    if instance and pk and view and is_registered(view.get_model()):
+        content_type = view.get_content_type()
+        endpoint = (
+            f'{reverse("wbcore:version-list", args=[], request=request)}?content_type={content_type.id}&object_id={pk}'
+        )
+        return bt.WidgetButton(endpoint=endpoint, label="History", icon=WBIcon.HISTORY.icon)

wbcore/reversion/viewsets/displays.py

@@ -0,0 +1,45 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class RevisionDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="date_created", label=_("Created At")),
+                dp.Field(key="user", label=_("User")),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [["date_created", "user"], [repeat_field(2, "versions_section")]],
+            [create_simple_section("versions_section", _("Versions"), [["versions"]], "versions", collapsed=False)],
+        )
+
+
+class VersionDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="id", label=_("ID")),
+                dp.Field(key="revision", label=_("Revision")),
+                dp.Field(key="date_created", label=_("Creation Date")),
+                # dp.Field(key="object_repr", label=_("Object repr")),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [["revision", "date_created"], ["object_repr", "object_id"], [repeat_field(2, "serialized_data")]]
+        )

wbcore/reversion/viewsets/endpoints.py

@@ -0,0 +1,30 @@
+from rest_framework.reverse import reverse
+
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class RevisionEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse("wbcore:revision-list", request=self.request)
+
+    def get_create_endpoint(self, **kwargs):
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        return None
+
+
+class VersionEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse("wbcore:version-list", request=self.request)
+
+    def get_create_endpoint(self, **kwargs):
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        return None
+
+
+class VersionRevisionEndpointConfig(VersionEndpointConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse("wbcore:revision-version-list", args=[self.view.kwargs["revision_id"]], request=self.request)

wbcore/reversion/viewsets/titles.py

@@ -0,0 +1,19 @@
+from contextlib import suppress
+
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ObjectDoesNotExist
+from django.utils.translation import gettext as _
+
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class VersionTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        if (content_type_id := self.view.request.GET.get("content_type", None)) and (
+            object_id := self.view.request.GET.get("object_id", None)
+        ):
+            with suppress(ObjectDoesNotExist):
+                content_type = ContentType.objects.get(id=content_type_id)
+                obj = content_type.model_class().objects.get(id=object_id)
+                return _("Versions For {obj}").format(obj=str(obj))
+        return _("Versions")