wbcore 2.2.1__py2.py3-none-any.whl

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,94 @@
+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,44 @@
+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,29 @@
+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,17 @@
+from django.contrib.contenttypes.models import ContentType
+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)
+        ):
+            try:
+                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))
+            except Exception:
+                pass
+        return _("Versions")

wbcore/reversion/viewsets/viewsets.py

@@ -0,0 +1,111 @@
+from django.db.models import F
+from django.shortcuts import get_object_or_404, render
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from reversion.models import Revision, Version
+from reversion_compare.mixins import CompareMixin
+from wbcore import viewsets
+
+from ..filters import RevisionFilterSet, VersionFilterSet
+from ..serializers import (
+    RevisionModelSerializer,
+    RevisionRepresentationSerializer,
+    VersionModelSerializer,
+    VersionRepresentationSerializer,
+)
+from .buttons import VersionButtonConfig
+from .displays import RevisionDisplayConfig, VersionDisplayConfig
+from .endpoints import (
+    RevisionEndpointConfig,
+    VersionEndpointConfig,
+    VersionRevisionEndpointConfig,
+)
+from .titles import VersionTitleConfig
+
+
+class VersionRepresentationViewSet(viewsets.RepresentationViewSet):
+    ordering_fields = ordering = ("id",)
+    # search_fields = ('user',)
+    serializer_class = VersionRepresentationSerializer
+    queryset = Version.objects.select_related("revision")
+    filterset_class = VersionFilterSet
+
+
+class RevisionRepresentationViewSet(viewsets.RepresentationViewSet):
+    ordering_fields = ordering = ("id",)
+    search_fields = ("user",)
+    serializer_class = RevisionRepresentationSerializer
+    queryset = Revision.objects.all()
+
+
+class RevisionModelViewSet(viewsets.ModelViewSet):
+    display_config_class = RevisionDisplayConfig
+    endpoint_config_class = RevisionEndpointConfig
+
+    queryset = Revision.objects.select_related("user")
+    serializer_class = RevisionModelSerializer
+
+    ordering = "-date_created"
+    ordering_fields = ("id", "date_created")
+    filterset_class = RevisionFilterSet
+
+
+class VersionModelViewSet(CompareMixin, viewsets.ModelViewSet):
+    display_config_class = VersionDisplayConfig
+    endpoint_config_class = VersionEndpointConfig
+    title_config_class = VersionTitleConfig
+    button_config_class = VersionButtonConfig
+    queryset = Version.objects.select_related("revision")
+    serializer_class = VersionModelSerializer
+    filterset_class = VersionFilterSet
+
+    ordering_fields = ("date_created",)
+    ordering = ("-date_created",)
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                date_created=F("revision__date_created"), profile_repr=F("revision__user__profile__computed_str")
+            )
+        )
+
+    @action(detail=True, methods=["GET"], permission_classes=[IsAuthenticated])
+    def revert(self, request, pk=None):
+        if request.user.is_superuser or request.user.has_perm("reversion.change_version"):
+            version1 = get_object_or_404(Version, pk=pk)
+            version1.revert()
+        return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=True, methods=["GET"], permission_classes=[IsAuthenticated])
+    def comparewith(self, request, pk=None):
+        if compare_with := request.GET.get("compare_with", None):
+            version1 = get_object_or_404(Version, pk=pk)
+            version2 = get_object_or_404(Version, pk=compare_with)
+            if version1.id > version2.id:
+                # Compare always the newest one (#2) with the older one (#1)
+                version1, version2 = version2, version1
+
+            obj = version1.content_type.model_class().objects.get(id=version1.object_id)
+            compare_data, has_unfollowed_fields = self.compare(obj, version1, version2)
+            return render(
+                request,
+                "reversion/compare_detail.html",
+                {
+                    "compare_data": compare_data,
+                    "has_unfollowed_fields": has_unfollowed_fields,
+                    "version1": version1,
+                    "version2": version2,
+                },
+            )
+        return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class VersionRevisionModelViewSet(VersionModelViewSet):
+    endpoint_config_class = VersionRevisionEndpointConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(revision=self.kwargs["revision_id"])

wbcore/routers.py

@@ -0,0 +1,63 @@
+from rest_framework.routers import DefaultRouter, DynamicRoute, Route
+
+
+class WBCoreRouter(DefaultRouter):
+    """
+    The default Django Rest Framework router with a destroy_multiple method
+    """
+
+    routes = [
+        # List route.
+        Route(
+            url=r"^{prefix}{trailing_slash}$",
+            mapping={"get": "list", "post": "create", "delete": "destroy_multiple"},
+            name="{basename}-list",
+            detail=False,
+            initkwargs={"suffix": "List"},
+        ),
+        # Dynamically generated list routes. Generated using
+        # @action(detail=False) decorator on methods of the viewset.
+        DynamicRoute(
+            url=r"^{prefix}/{url_path}{trailing_slash}$",
+            name="{basename}-{url_name}",
+            detail=False,
+            initkwargs={},
+        ),
+        # Detail route.
+        Route(
+            url=r"^{prefix}/{lookup}{trailing_slash}$",
+            mapping={
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            },
+            name="{basename}-detail",
+            detail=True,
+            initkwargs={"suffix": "Instance"},
+        ),
+        # Dynamically generated detail routes. Generated using
+        # @action(detail=True) decorator on methods of the viewset.
+        DynamicRoute(
+            url=r"^{prefix}/{lookup}/{url_path}{trailing_slash}$",
+            name="{basename}-{url_name}",
+            detail=True,
+            initkwargs={},
+        ),
+        Route(
+            url=r"^{prefix}/{lookup}/history{trailing_slash}$",
+            mapping={"get": "history_list"},
+            name="{basename}-history-list",
+            detail=False,
+            initkwargs={"suffix": "History List", "historical_mode": True},
+        ),
+        Route(
+            url=r"^{prefix}/{lookup}/history/(?P<history_id>[^/.]+){trailing_slash}$",
+            mapping={
+                "get": "history_retrieve",
+            },
+            name="{basename}-history-detail",
+            detail=True,
+            initkwargs={"suffix": "History Instance", "historical_mode": False},
+        ),
+    ]

wbcore/search/__init__.py

@@ -0,0 +1,62 @@
+import operator
+from functools import reduce
+
+from django.db.models import F, Q, QuerySet, Value
+from django.db.models.functions import Concat
+
+search_models = []
+
+
+class SearchRegistry:
+    def __init__(self):
+        self._registry = {}
+
+    def register(self, _class, endpoint):
+        self._registry[_class.__name__] = {
+            "class": _class,
+            "verbose_name": _class._meta.verbose_name,
+            "endpoint": endpoint,
+        }
+
+    def registered_models(self):
+        yield from self._registry.items()
+
+
+registry = SearchRegistry()
+
+
+def register(endpoint):
+    def _search_wrapper(model_class):
+        registry.register(model_class, endpoint)
+        return model_class
+
+    return _search_wrapper
+
+
+def search(search_term, request=None):
+    qs = None
+    for key, values in registry._registry.items():
+        # filtering = reduce(
+        #     lambda x, y: operator.and_(
+        #         Q(__search__icontains=x), Q(__search__icontains=y)
+        #     ),
+        #     search_term.split(" "),
+        # )
+
+        _qs = (
+            values["class"]
+            .search_for_term(search_term, request)
+            .annotate(__search=Concat(F("_search"), Value(f" {values['verbose_name']}")))
+        )
+
+        for term in search_term.split(" "):
+            _qs = _qs.filter(__search__icontains=term)
+
+        _qs = _qs.values("id", "_repr", "__search")
+
+        if qs is None:
+            qs = _qs
+        else:
+            qs = qs.union(_qs)
+
+    return qs

wbcore/serializers/__init__.py

@@ -0,0 +1,66 @@
+from .fields import (
+    AdditionalResourcesField,
+    BooleanField,
+    CharField,
+    ChoiceField,
+    CodeField,
+    ColorPickerField,
+    DateField,
+    DateRangeField,
+    DateTimeField,
+    DateTimeRangeField,
+    DecimalField,
+    DecimalRangeField,
+    DynamicButtonField,
+    EmojiRatingField,
+    FileField,
+    FloatField,
+    FSMStatusField,
+    HyperlinkField,
+    ImageField,
+    ImageURLField,
+    IntegerField,
+    YearField,
+    JSONField,
+    JSONTableField,
+    JSONTextEditorField,
+    ListField,
+    ListSerializer,
+    MarkdownTextField,
+    MultipleChoiceField,
+    PrimaryKeyCharField,
+    PrimaryKeyField,
+    PrimaryKeyRelatedField,
+    RangeSelectField,
+    ReadOnlyField,
+    SlugRelatedField,
+    ReturnContentType,
+    SerializerMethodField,
+    SparklineField,
+    StarRatingField,
+    StringRelatedField,
+    TelephoneField,
+    TemplatedJSONTextEditor,
+    TextAreaField,
+    TextField,
+    TimeField,
+    TimeZoneField,
+    URLField,
+    WBCoreType,
+    decorator,
+    percent_decorator,
+    register_dynamic_button,
+    register_only_instance_dynamic_button,
+    register_only_instance_resource,
+    register_resource,
+)
+from .serializers import ModelSerializer, RepresentationSerializer, Serializer
+from .utils import (
+    CurrentUserDefault,
+    DefaultAttributeFromRemoteField,
+    DefaultFromGET,
+    DefaultFromKwargs,
+    DefaultFromGetOrKwargs,
+    DefaultAttributeFromObject,
+    DefaultFromView,
+)

wbcore/serializers/fields/__init__.py

@@ -0,0 +1,58 @@
+from wbcore.contrib.icons.serializers import IconSelectField
+
+from .boolean import BooleanField
+from .choice import ChoiceField, MultipleChoiceField
+from .datetime import (
+    DateField,
+    DateRangeField,
+    DateTimeField,
+    DateTimeRangeField,
+    DurationField,
+    TimeField,
+    TimeZoneField,
+)
+from .fields import (
+    AdditionalResourcesField,
+    DynamicButtonField,
+    HyperlinkField,
+    ReadOnlyField,
+    SlugRelatedField,
+    SerializerMethodField,
+    register_dynamic_button,
+    register_only_instance_dynamic_button,
+    register_only_instance_resource,
+    register_resource,
+)
+from .file import FileField, ImageField, ImageURLField, UnsafeImageField
+from .fsm import FSMStatusField
+from .json import (
+    JSONField,
+    JSONTableField,
+    JSONTextEditorField,
+    TemplatedJSONTextEditor,
+)
+from .list import ListField, SparklineField
+from .mixins import decorator
+from .number import (
+    DecimalField,
+    DecimalRangeField,
+    FloatField,
+    IntegerField,
+    YearField,
+    percent_decorator,
+)
+from .other import EmojiRatingField, RangeSelectField, StarRatingField
+from .primary_key import PrimaryKeyCharField, PrimaryKeyField
+from .related import ListSerializer, PrimaryKeyRelatedField
+from .text import (
+    CharField,
+    CodeField,
+    ColorPickerField,
+    MarkdownTextField,
+    StringRelatedField,
+    TelephoneField,
+    TextAreaField,
+    TextField,
+    URLField,
+)
+from .types import ReturnContentType, WBCoreType

wbcore/serializers/fields/boolean.py

@@ -0,0 +1,51 @@
+from typing import Any, Iterable
+
+from rest_framework import serializers
+
+from .mixins import WBCoreSerializerFieldMixin
+from .types import WBCoreType
+
+
+class BooleanField(WBCoreSerializerFieldMixin, serializers.BooleanField):
+    field_type = WBCoreType.BOOLEAN.value
+
+    def __init__(
+        self,
+        labels: Iterable[str] | None = None,
+        values: Iterable[Any] | None = None,
+        background_color: str | Iterable[str] | None = None,
+        color: str | Iterable[str] | None = None,
+        active_background_color: str | Iterable[str] | None = None,
+        active_color: str | Iterable[str] | None = None,
+        **kwargs
+    ):
+        self.labels = labels
+        self.values = values
+        self.background_color = background_color
+        self.color = color
+        self.active_background_color = active_background_color
+        self.active_color = active_color
+        super().__init__(**kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        field_name, representation = super().get_representation(request, field_name)
+
+        if self.labels:
+            representation["labels"] = self.labels
+
+        if self.values:
+            representation["values"] = self.values
+
+        if self.background_color:
+            representation["background_color"] = self.background_color
+
+        if self.color:
+            representation["color"] = self.color
+
+        if self.active_background_color:
+            representation["active_background_color"] = self.active_background_color
+
+        if self.active_color:
+            representation["active_color"] = self.active_color
+
+        return field_name, representation

wbcore/serializers/fields/choice.py

@@ -0,0 +1,36 @@
+from rest_framework import serializers
+
+from .list import ListFieldMixin
+from .mixins import WBCoreSerializerFieldMixin
+from .types import WBCoreType
+
+
+class ChoiceField(WBCoreSerializerFieldMixin, serializers.ChoiceField):
+    field_type = WBCoreType.SELECT.value
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["choices"] = [{"value": k, "label": v} for k, v in self.choices.items()]
+        return key, representation
+
+
+class MultipleChoiceField(ListFieldMixin, WBCoreSerializerFieldMixin, serializers.MultipleChoiceField):
+    field_type = WBCoreType.SELECT.value
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["multiple"] = True
+        representation["choices"] = [{"value": k, "label": v} for k, v in self.choices.items()]
+        return key, representation
+
+    def to_internal_value(self, data):
+        data = super().to_internal_value(data)
+        if isinstance(data, set):
+            data = list(data)
+        return data
+
+    def to_representation(self, data):
+        data = super().to_representation(data)
+        if isinstance(data, set):
+            data = list(data)
+        return data