wbcore 2.2.1__py2.py3-none-any.whl

wbcore/utils/urls.py

@@ -0,0 +1,70 @@
+import urllib.parse
+from typing import Dict, Tuple
+
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.http.request import QueryDict
+from django.utils.http import urlencode
+
+
+def clean_shareable_url(url):
+    endpoint = url.split("?widget_endpoint=")[-1]
+    parse_url = urllib.parse.urlsplit(urllib.parse.unquote(endpoint))
+    endpoint = parse_url.path
+    if params := dict(urllib.parse.parse_qsl(parse_url.query)):
+        params_repr = "&".join([f"{k}={v}" for k, v in params.items()])
+        endpoint += f"?{params_repr}"
+    return endpoint
+
+
+def get_parse_endpoint(endpoint: str) -> Tuple[str, Dict[str, str]]:
+    """
+    Takes a URL endpoint and outputs the path and the params separately.
+
+    Parameters
+    ----------
+    endpoint: The endpoint string
+
+    Returns
+    -------
+    Returns a tuple in the form of (path: str, params: dict[str, str]). Where path is the url and params are the parameters of the endpoint.
+    """
+
+    path = urllib.parse.urljoin(endpoint, urllib.parse.urlparse(endpoint).path)
+    params = dict(urllib.parse.parse_qsl(urllib.parse.urlsplit(endpoint).query))
+    return path, params
+
+
+def get_urlencode_endpoint(endpoint: str, params: Dict[str, str]) -> str:
+    """
+    Takes a URL path and params and creates an endpoint from it.
+
+    Parameters
+    ----------
+    endpoint: The URL string
+    params: The params dictonary
+
+    Returns
+    -------
+    Returns an endpoint string with the params attached.
+    """
+    if isinstance(params, QueryDict):
+        params = params.dict()
+    return f"{endpoint}?{urlencode(params)}"
+
+
+def base_domain() -> str:
+    """A utility method that assembles the current domain. Utilizes the site app from django
+
+    Returns:
+        A string containing the current domain as noted in the curret `Site` prefixed with the http scheme
+
+    """
+    scheme = "https" if settings.SECURE_SSL_REDIRECT else "http"
+    base_domain = Site.objects.get_current().domain
+    return f"{scheme}://{base_domain}"
+
+
+def new_mode(url: str) -> str:
+    operator = "&" if "?" in url else "?"
+    return url + f"{operator}new_mode=true"

wbcore/utils/views.py

@@ -0,0 +1,201 @@
+import importlib
+import re
+from functools import cached_property
+
+from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+from django.dispatch import receiver
+from django.shortcuts import get_object_or_404
+from django.urls import resolve
+from django.urls.exceptions import NoReverseMatch
+from django.utils.translation import gettext as _
+from rest_framework import status
+from rest_framework.decorators import action, api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializer
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.models.base import merge_as_task
+from wbcore.signals.instance_buttons import add_extra_button
+
+
+def parse_query_parameters_list(list_str):
+    try:
+        return list(set(map(lambda x: int(x), filter(None, list_str.split(",")))))
+    except ValueError:
+        return ""
+
+
+def set_identifier(identifier):
+    def decorator(func):
+        func.identifier = identifier
+        return func
+
+    return decorator
+
+
+@api_view(["GET"])
+@permission_classes([IsAuthenticated])
+def api_endpoints_root(request, format=None):
+    try:
+        endpoints = dict()
+        for wb_endpoint in settings.WB_ENDPOINTS:
+            try:
+                endpoints[wb_endpoint] = reverse(f"{wb_endpoint}:api-root", request=request, format=format)
+            except NoReverseMatch:
+                pass
+
+        return Response(endpoints)
+
+    except AttributeError:
+        return Response({"error": "No Endpoints specified."}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class CloneMixin:
+    """
+    This Mixin can be used to inherit the clone functionality out of the box. This mixin will register the additional resources
+    and the appropriate button to allow user to clone a given instance
+    """
+
+    def get_clone_instance_display(self) -> Display | None:
+        """
+        Return the instance display to show in the clone action button. Default to return None (i.e. No form)
+        """
+        return None
+
+    @action(methods=["PATCH"], detail=True)
+    def clone(self, request, pk=None):
+        instance = get_object_or_404(self.queryset.model, pk=pk)
+        if (clone_fct := getattr(instance, "clone", None)) and callable(clone_fct):
+            kwargs = {}
+            if request.data:
+                serializer = self.get_serializer_class()(data=request.data)
+                serializer.is_valid(raise_exception=False)
+                kwargs = serializer.data
+            cloned_obj = clone_fct(user=request.user, **kwargs)
+            if (
+                cloned_obj
+                and (clone_id := getattr(cloned_obj, "id", None))
+                and (endpoint_config_class := getattr(self, "endpoint_config_class", None))
+            ):
+                endpoint_config = endpoint_config_class(self, request, cloned_obj)
+                if endpoint := endpoint_config.get_instance_endpoint():
+                    return Response(
+                        {
+                            "endpoint": re.sub(
+                                pattern=r"[^\/]+(?=\/$|$)",
+                                repl=str(clone_id),
+                                string=endpoint,
+                            )
+                        }
+                    )
+        return Response({})
+
+
+@receiver(add_extra_button)
+def add_clone_extra_button(sender, instance, request, view, pk=None, **kwargs):
+    if instance and pk and issubclass(view.__class__, CloneMixin):
+        object = view.get_object()
+        if getattr(object, "is_cloneable", True) and (endpoint_basename := object.get_endpoint_basename()):
+            endpoint = reverse(f"{endpoint_basename}-clone", args=[pk], request=request)
+            identifier = getattr(view, "IDENTIFIER", "{0.app_label}:{0.model}".format(view.get_content_type()))
+            return bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=(identifier,),
+                endpoint=endpoint,
+                action_label=_("Clone"),
+                title=_("Clone"),
+                label=_("Clone"),
+                icon=WBIcon.COPY.icon,
+                instance_display=view.get_clone_instance_display(),
+            )
+
+
+class MergeMixin:
+    """
+    This Mixin can be used to inherit the clone functionality out of the box. This mixin will register the additional resources
+    and the appropriate button to allow user to merge a given instance
+    """
+
+    @cached_property
+    def model(self):
+        return self.queryset.model
+
+    @cached_property
+    def has_user_merge_permission(self) -> bool:
+        return getattr(self, "MERGE_PERMISSION", f"administrate_{self.model._meta.model_name}")
+
+    @cached_property
+    def can_merge(self):
+        return hasattr(self.queryset.model, "merge") and self.has_user_merge_permission
+
+    def get_merged_object_representation_serializer(self):
+        """
+        Return the representation serializer used for the action button merged object field. Default to the model representation endpoint serializer
+        """
+        view_func = resolve(reverse(self.model.get_representation_endpoint())).func
+        module = importlib.import_module(view_func.__module__)
+        view = getattr(module, view_func.__name__)
+        return view.serializer_class
+
+    def get_merged_object_representation_serializer_filter_params(self) -> dict[str, str]:
+        """
+        Return the representation serializer filter kwargs. Default to an empty dict
+        """
+        return dict()
+
+    @action(methods=["PATCH"], detail=True)
+    def merge(self, request, pk=None):
+        instance = get_object_or_404(self.queryset.model, pk=pk)
+        merged_instance = get_object_or_404(self.queryset.model, pk=request.POST.get("merged_object", None))
+        try:
+            content_type = ContentType.objects.get_for_model(self.model)
+        except ContentType.DoesNotExist:
+            content_type = None
+        if content_type and self.has_user_merge_permission and hasattr(instance, "merge"):
+            merge_as_task.delay(content_type.id, instance.id, merged_instance.id)
+            return Response({"status": "Merged with success"})
+        return Response({}, status=400)
+
+
+@receiver(add_extra_button)
+def add_merge_extra_button(sender, instance, request, view, pk=None, **kwargs):
+    if instance and pk and issubclass(view.__class__, CloneMixin) and getattr(view, "can_merge", False):
+        object = view.get_object()
+        if getattr(object, "is_mergeable", True) and (endpoint_basename := object.get_endpoint_basename()):
+            endpoint = reverse(f"{endpoint_basename}-merge", args=[pk], request=request)
+            identifier = getattr(view, "IDENTIFIER", "{0.app_label}:{0.model}".format(view.get_content_type()))
+
+            class MergeSerializer(wb_serializer.ModelSerializer):
+                merged_object = wb_serializer.PrimaryKeyRelatedField(queryset=view.model.objects.all())
+                _merged_object = view.get_merged_object_representation_serializer()(
+                    source="merged_object",
+                    filter_params=view.get_merged_object_representation_serializer_filter_params(),
+                )
+
+                class Meta:
+                    model = view.model
+                    fields = [
+                        "id",
+                        "merged_object",
+                        "_merged_object",
+                    ]
+
+            return bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=(identifier,),
+                endpoint=endpoint,
+                action_label=_("Merge"),
+                title=_("Merge"),
+                label=_("Merge"),
+                icon=WBIcon.MERGE.icon,
+                serializer=MergeSerializer,
+                instance_display=create_simple_display([["merged_object"]]),
+            )

wbcore/views.py

@@ -0,0 +1,26 @@
+from django.conf import settings
+from django.utils.module_loading import import_string
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework.views import APIView
+
+
+class Profile(APIView):
+    """Profile view to get the default user name, email and profile
+
+    This view should be substituted by one from the authentication module
+    """
+
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request: Request) -> Response:
+        return Response(
+            {
+                "config": reverse("wbcore:frontenduserconfiguration-list", request=request),
+                "name": import_string(settings.WBCORE_DEFAULT_USER_NAME)(request.user),
+                "email": request.user.email,
+                "profile": import_string(settings.WBCORE_PROFILE)(request),
+            }
+        )

wbcore/viewsets/__init__.py

@@ -0,0 +1,10 @@
+from .utils import PreAction
+from .viewsets import (
+    ChartViewSet,
+    InfiniteDataModelView,
+    ModelViewSet,
+    ReadOnlyInfiniteModelViewSet,
+    ReadOnlyModelViewSet,
+    RepresentationViewSet,
+    ViewSet,
+)

wbcore/viewsets/encoders.py

@@ -0,0 +1,18 @@
+import json
+import types
+
+from django.core.serializers.json import DjangoJSONEncoder
+from rest_framework.renderers import JSONRenderer
+
+
+class PandasDataCustomEncoder(json.JSONEncoder):
+    def default(self, obj):
+        # We need to handle generator for option request that sometime contains generator as values
+        if isinstance(obj, types.GeneratorType):
+            return list(obj)
+        return DjangoJSONEncoder().default(obj)
+
+
+class PandasDataCustomRenderer(JSONRenderer):
+    encoder_class = PandasDataCustomEncoder
+    strict = False

wbcore/viewsets/generics.py

@@ -0,0 +1,5 @@
+from rest_framework.generics import GenericAPIView as OriginalGenericAPIView
+
+
+class GenericAPIView(OriginalGenericAPIView):
+    pass

wbcore/viewsets/mixins.py

@@ -0,0 +1,290 @@
+from typing import Iterable
+
+from django.contrib.messages import get_messages
+from django.contrib.staticfiles import finders
+from django.db import IntegrityError
+from django.db.models import F, Model, QuerySet
+from django.db.models.expressions import OrderBy
+from django.http import Http404
+from django.shortcuts import get_object_or_404
+from django.templatetags.static import static
+from django.utils.functional import cached_property
+from rest_framework.decorators import action
+from rest_framework.filters import OrderingFilter, SearchFilter
+from rest_framework.mixins import CreateModelMixin as OriginalCreateModelMixin
+from rest_framework.mixins import DestroyModelMixin as OriginalDestroyModelMixin
+from rest_framework.mixins import ListModelMixin as OriginalListModelMixin
+from rest_framework.mixins import RetrieveModelMixin as OriginalRetrieveModelMixin
+from rest_framework.mixins import UpdateModelMixin as OriginalUpdateModelMixin
+from rest_framework.pagination import BasePagination
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.status import (
+    HTTP_200_OK,
+    HTTP_204_NO_CONTENT,
+    HTTP_400_BAD_REQUEST,
+    HTTP_405_METHOD_NOT_ALLOWED,
+    HTTP_409_CONFLICT,
+)
+from wbcore.filters import DjangoFilterBackend
+from wbcore.messages import InMemoryMessageStorage
+
+
+def map_ordering(order_str: str) -> OrderBy:
+    asc_desc = "desc" if order_str[0] == "-" else "asc"
+    remove_strings = ["-", "__nulls_last", "__nulls_first"]
+    clean_order_str = order_str
+    for string in remove_strings:
+        clean_order_str = clean_order_str.replace(string, "")
+    asc_desc_function = getattr(F(clean_order_str), asc_desc)
+    if "__nulls_last" in order_str:
+        return asc_desc_function(nulls_last=True)
+    elif "__nulls_first" in order_str:
+        return asc_desc_function(nulls_first=True)
+    return asc_desc_function()
+
+
+class WBCoreOrderingFilter(OrderingFilter):
+    def get_mandatory_ordering_fields(self, queryset, view) -> list[str]:
+        """
+        Given the queryset and the view, extract the mandatory field for the final ordering. Default to ["id"]
+
+        To keep it simple, we assume that all view have a id field defined in the serializer. If this is not the case, we expect the dev to override this method and return an empty list.
+        """
+        if (fct := getattr(view, "get_mandatory_ordering_fields", None)) and callable(fct):
+            fields = fct()
+        else:
+            fields = ["id"]
+        return fields
+
+    def filter_queryset(self, request, queryset, view):
+        ordering = self.get_ordering(request, queryset, view)
+        mandatory_ordering_fields = self.get_mandatory_ordering_fields(queryset, view)
+        if ordering or mandatory_ordering_fields:
+            return queryset.order_by(*map(map_ordering, ordering), *mandatory_ordering_fields)
+
+        return queryset
+
+    def get_valid_fields(self, queryset, view, context={}):
+        valid_fields = view.get_ordering_fields()
+        if valid_fields is None:
+            # Default to allowing filtering on serializer fields
+            return self.get_default_valid_fields(queryset, view, context)
+
+        elif valid_fields == "__all__":
+            # View explicitly allows filtering on any model field
+            valid_fields = [(field.name, field.verbose_name) for field in queryset.model._meta.fields]
+            valid_fields += [(key, key.title().split("__")) for key in queryset.query.annotations]
+        else:
+            valid_fields = [(item, item) if isinstance(item, str) else item for item in valid_fields]
+        return valid_fields
+
+
+class FilterMixin:
+    filter_backends = (DjangoFilterBackend, SearchFilter, WBCoreOrderingFilter)
+    filterset_fields = {}
+    search_fields = []
+    ordering_fields = ordering = ("id",)
+
+
+class DocumentationMixin:
+    def _get_documentation_url(self, detail):
+        INSTANCE_DOCUMENTATION = getattr(self, "INSTANCE_DOCUMENTATION", None)
+        LIST_DOCUMENTATION = getattr(self, "LIST_DOCUMENTATION", None)
+        doc = INSTANCE_DOCUMENTATION if detail else LIST_DOCUMENTATION
+
+        if doc and finders.find(doc):
+            return static(doc)
+        return None
+
+
+class ActionMixin:
+    kwargs: dict
+    request: Request
+    action: str
+
+    def get_action(self) -> str:
+        if self.action == "metadata":
+            if bool(self.request.GET.get("new_mode")):
+                return "create-metadata"
+            if bool(self.kwargs.get("pk")):
+                return "retrieve-metadata"
+            else:
+                return "list-metadata"
+        return self.action
+
+
+class MessageMixin:
+    def add_messages(
+        self,
+        request: Request,
+        queryset: QuerySet | None = None,
+        paginated_queryset: BasePagination | None = None,
+        instance: Model | None = None,
+        initial: bool = False,
+    ):
+        ...
+
+    def _get_messages(
+        self,
+        request: Request,
+        queryset: QuerySet | None = None,
+        paginated_queryset: BasePagination | None = None,
+        instance: Model | None = None,
+        initial: bool = False,
+    ) -> Iterable[dict[str, str]]:
+        # We call add_messages to collect messages from the view which weren't created at other places
+        # because they might need some more information under which circumstances they are being called
+        self.add_messages(
+            request=request,
+            queryset=queryset,
+            paginated_queryset=paginated_queryset,
+            instance=instance,
+            initial=initial,
+        )
+
+        # We get the storage backend and yield all messages in a serialized form
+        # This only works if the storage backend is our custom InMemoryMessageStorage
+        # We inject request._request purely for typing, as request will defer attribute
+        # lookup to its internal getattribute method. But the get_messages method only
+        # accepts a HttpRequest object which is DRF request simply wraps
+        storage = get_messages(request._request)
+        if isinstance(storage, InMemoryMessageStorage):
+            yield from storage.serialize_messages()
+
+
+class ListModelMixin(MessageMixin, OriginalListModelMixin):
+    def list(self, request, *args, **kwargs):
+        queryset = self.get_queryset()
+        if queryset.exists():
+            queryset = self.filter_queryset(queryset)
+
+        page = self.paginate_queryset(queryset)
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            response = self.get_paginated_response(serializer.data)
+            response.data["messages"] = list(
+                self._get_messages(
+                    request, queryset=queryset, paginated_queryset=page, initial=self._paginator.is_initial()
+                )
+            )
+
+            if hasattr(self, "get_aggregates"):
+                response.data["aggregates"] = self.get_aggregates(queryset=queryset, paginated_queryset=page)
+        else:
+            serializer = self.get_serializer(queryset, many=True)
+            response = Response(serializer.data)
+            response.data = {"results": response.data}
+
+            response.data["messages"] = list(self._get_messages(request, queryset=queryset, initial=True))
+
+            if hasattr(self, "get_aggregates"):
+                response.data["aggregates"] = self.get_aggregates(queryset=queryset, paginated_queryset=queryset)
+
+        return response
+
+
+class RetrieveModelMixin(MessageMixin, OriginalRetrieveModelMixin):
+    def retrieve(self, request, *args, **kwargs):
+        response = super().retrieve(request, *args, **kwargs)
+        response.data = {"instance": response.data}
+        try:
+            instance = self.get_object()
+        except Http404:
+            instance = None
+        response.data["messages"] = list(self._get_messages(request, instance=instance))
+        return response
+
+
+class CreateModelMixin(OriginalCreateModelMixin):
+    def create(self, request, *args, **kwargs):
+        # If not create endpoint is defined then raise 405
+        if self.endpoint_config_class(view=self, request=self.request, instance=False)._get_create_endpoint() is None:
+            return Response(status=HTTP_405_METHOD_NOT_ALLOWED)
+
+        response = super().create(request, *args, **kwargs)
+        response.data = {"instance": response.data, "messages": list(self._get_messages(request))}
+        return response
+
+
+class UpdateModelMixin(OriginalUpdateModelMixin):
+    def update(self, request, *args, **kwargs):
+        # If no instance endpoint is defined, then raise 405
+        if self.endpoint_config_class(view=self, request=self.request, instance=True)._get_update_endpoint() is None:
+            return Response(status=HTTP_405_METHOD_NOT_ALLOWED)
+
+        response = super().update(request, *args, **kwargs)
+        response.data = {"instance": response.data}
+        try:
+            instance = self.get_object()
+        except Http404:
+            instance = None
+        response.data["messages"] = list(self._get_messages(request, instance=instance))
+        return response
+
+
+class DestroyModelMixin(OriginalDestroyModelMixin):
+    def destroy(self, request, *args, **kwargs):
+        # If no delete endpoint is defined, then raise 405
+        if self.endpoint_config_class(view=self, request=self.request, instance=True)._get_delete_endpoint() is None:
+            return Response(status=HTTP_405_METHOD_NOT_ALLOWED)
+
+        return super().destroy(request, *args, **kwargs)
+
+
+class DestroyMultipleModelMixin:
+    def destroy_multiple(self, request, *args, **kwargs):
+        # If no delete endpoint is defined, then raise 405
+        if self.endpoint_config_class(view=self, request=self.request, instance=False)._get_delete_endpoint() is None:
+            return Response(status=HTTP_405_METHOD_NOT_ALLOWED)
+
+        model = self.get_serializer_class().Meta.model
+        app_label = model._meta.app_label
+
+        queryset = model.objects.filter(id__in=request.data)
+        destroyed = self.perform_destroy_multiple(queryset)
+        return Response({"count": destroyed[1].get(f"{app_label}.{model.__name__}", 0)}, status=HTTP_204_NO_CONTENT)
+
+    def perform_destroy_multiple(self, queryset):
+        return queryset.delete()
+
+
+class OrderableMixin:
+    # This mixin will not work if the viewset model does not inherit from ordered_model.models.OrderedModel
+
+    ordering = ("order",)
+
+    @action(methods=["PATCH"], detail=True)
+    def reorder(self, request: Request, pk=None, **kwargs) -> Response:
+        instance = self.get_object()
+        order = request.data.get("order")
+        if order is None:
+            return Response("No order received", status=HTTP_400_BAD_REQUEST)
+        instance.to(order)
+        return Response("Reordering Successful", status=HTTP_200_OK)
+
+
+class ReparentMixin:
+    PARENT_FIELD: str
+    PARENT_MODEL: type[Model]
+
+    @property
+    def parent_field(self) -> str:
+        return self.PARENT_FIELD
+
+    @cached_property
+    def model(self):
+        return self.queryset.model
+
+    @action(methods=["PATCH"], detail=True)
+    def reparent(self, request: Request, pk=None, **kwargs) -> Response:
+        instance = self.get_object()
+        new_parent = get_object_or_404(self.PARENT_MODEL, pk=request.data.get("new_parent"))
+        old_parent = getattr(instance, self.parent_field)
+        if old_parent != new_parent:
+            setattr(instance, self.parent_field, new_parent)
+            try:
+                instance.save()
+            except IntegrityError:
+                return Response("Cannot reparent due to conflict", status=HTTP_409_CONFLICT)
+        return Response("Reparenting Successful", status=HTTP_200_OK)

wbcore/viewsets/utils.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+
+from django.utils.translation import gettext as _
+from rest_framework.response import Response
+from wbcore.metadata.configs.buttons import ButtonConfig
+from wbcore.metadata.configs.display.instance_display import Display
+
+
+@dataclass
+class PreAction:
+    message: str
+    instance_display: Display | None = None
+    confirm_config: ButtonConfig = ButtonConfig(label=_("Confirm"), title=_("Confirm"))
+    cancel_config: ButtonConfig = ButtonConfig(label=_("Cancel"), title=_("Cancel"))
+
+    def to_response(self):
+        response_dict = {
+            "message": self.message,
+            "confirm_config": dict(self.confirm_config),
+            "cancel_config": dict(self.cancel_config),
+        }
+
+        if self.instance_display:
+            response_dict["display"] = self.instance_display.serialize()
+
+        return Response(response_dict)