wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/notifications/viewsets/configs/notifications.py

@@ -0,0 +1,91 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons.icons import WBIcon
+from wbcore.contrib.notifications.models import Notification
+from wbcore.metadata.configs.buttons.buttons import (
+    ActionButton,
+    HyperlinkButton,
+    RequestType,
+    WidgetButton,
+)
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display import Field, ListDisplay
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class NotificationButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self) -> set[ActionButton]:
+        if not self.view.kwargs.get("pk", None):
+            return {
+                ActionButton(
+                    weight=0,
+                    method=RequestType.PATCH,
+                    action_label=_("Reading all notifications"),
+                    endpoint=reverse("wbcore:notifications:notification-read-all", request=self.request),
+                    description_fields=_("Do you want to mark notifications as read?"),
+                    label=_("Mark all read"),
+                    icon=WBIcon.VIEW.icon,
+                    identifiers=["notifications:notification"],
+                ),
+                ActionButton(
+                    weight=1,
+                    method=RequestType.PATCH,
+                    action_label=_("Deleting all read notifications"),
+                    endpoint=reverse("wbcore:notifications:notification-delete-all-read", request=self.request),
+                    description_fields=_("Do you want delete all read notifications?"),
+                    label=_("Delete all read"),
+                    icon=WBIcon.DELETE.icon,
+                    identifiers=["notifications:notification"],
+                ),
+            }
+        return set()
+
+    def get_custom_instance_buttons(self) -> set[WidgetButton]:
+        resource_button_label = _("Open Resource")
+        if pk := self.view.kwargs.get("pk", None):
+            notification = Notification.objects.get(id=pk)
+            resource_button_label = notification.notification_type.resource_button_label
+
+        return {
+            WidgetButton(
+                title=resource_button_label,
+                label=resource_button_label,
+                icon=WBIcon.LINK.icon,
+                key="open_internal_resource",
+            ),
+            HyperlinkButton(
+                title=resource_button_label,
+                label=resource_button_label,
+                icon=WBIcon.LINK.icon,
+                key="open_external_resource",
+            ),
+        }
+
+    def get_custom_list_instance_buttons(self) -> set[WidgetButton]:
+        return self.get_custom_instance_buttons()
+
+
+class NotificationDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return ListDisplay(
+            fields=[
+                Field(key="notification_type", label="Type"),
+                Field(key="title", label="Title"),
+                Field(key="body", label="body"),
+                Field(key="sent", label="Sent"),
+                Field(key="read", label="Read"),
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["notification_type", ".", "."],
+                ["title", "sent", "read"],
+                ["body", "body", "body"],
+            ]
+        )

wbcore/contrib/notifications/viewsets/menus.py

@@ -0,0 +1,15 @@
+from django.utils.translation import gettext_lazy as _
+
+from wbcore.menus import ItemPermission, MenuItem
+
+NotificationTypeMenuItem = MenuItem(
+    label=_("Notification Types"),
+    endpoint="wbcore:notifications:notification_type_setting-list",
+    permission=ItemPermission(permissions=["notifications.view_notificationtype"]),
+)
+
+NotificationMenuItem = MenuItem(
+    label=_("Notifications"),
+    endpoint="wbcore:notifications:notification-list",
+    permission=ItemPermission(permissions=["notifications.view_notification"]),
+)

wbcore/contrib/notifications/viewsets/notification_types.py

@@ -0,0 +1,51 @@
+from django.db.models import Case, Value, When
+from django.db.models.query import F, QuerySet
+from rest_framework import status
+from rest_framework.request import Request
+from rest_framework.response import Response
+
+from wbcore import viewsets
+from wbcore.contrib.notifications.models import (
+    NotificationType,
+    NotificationTypeSetting,
+)
+from wbcore.contrib.notifications.serializers import (
+    NotificationTypeRepresentationSerializer,
+    NotificationTypeSettingModelSerializer,
+)
+
+from ...icons import WBIcon
+from .configs.notification_types import NotificationTypeSettingDisplayConfig, NotificationTypeSettingEndpointConfig
+
+
+class NotificationTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = NotificationType.objects.all()
+    serializer_class = NotificationTypeRepresentationSerializer
+
+
+class NotificationTypeSettingModelViewSet(viewsets.ModelViewSet):
+    queryset = NotificationTypeSetting.objects.all()
+    serializer_class = NotificationTypeSettingModelSerializer
+
+    endpoint_config_class = NotificationTypeSettingEndpointConfig
+    display_config_class = NotificationTypeSettingDisplayConfig
+
+    search_fields = ["notification_type__title", "notification_type__help_text"]
+
+    def create(self, request: Request) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def destroy(self, request: Request, pk=None) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def get_queryset(self) -> QuerySet[NotificationTypeSetting]:
+        return (
+            super()
+            .get_queryset()
+            .filter(user=self.request.user)
+            .annotate(
+                help_text=F("notification_type__help_text"),
+                locked=F("notification_type__is_lock"),
+                locked_icon=Case(When(locked=True, then=Value(WBIcon.LOCK.icon)), default=Value(None)),
+            )
+        )

wbcore/contrib/notifications/viewsets/notifications.py

@@ -0,0 +1,58 @@
+from django.db.models.query import QuerySet
+from django.utils import timezone
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.request import Request
+from rest_framework.response import Response
+
+from wbcore import viewsets
+from wbcore.contrib.notifications.models import Notification
+from wbcore.contrib.notifications.serializers import NotificationModelSerializer
+from wbcore.contrib.notifications.viewsets.configs.notifications import (
+    NotificationButtonConfig,
+    NotificationDisplayConfig,
+)
+
+
+class NotificationModelViewSet(viewsets.ModelViewSet):
+    ordering = ("-created",)
+    search_fields = ("title", "notification_type__title")
+
+    queryset = Notification.objects.all()
+
+    serializer_class = NotificationModelSerializer
+    display_config_class = NotificationDisplayConfig
+    button_config_class = NotificationButtonConfig
+
+    def retrieve(self, request: Request, *args, **kwargs) -> Response:
+        obj = self.get_object()
+        if not obj.read:
+            obj.read = timezone.now()
+            obj.save()
+        return super().retrieve(request, *args, **kwargs)
+
+    def create(self, request: Request) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def update(self, request: Request, pk=None) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def partial_update(self, request: Request, pk=None) -> Response:
+        return Response(status=status.HTTP_403_FORBIDDEN)
+
+    def get_queryset(self) -> QuerySet[Notification]:
+        return super().get_queryset().filter(user=self.request.user)
+
+    @action(methods=["GET"], detail=False)
+    def unread_count(self, request, pk=None):
+        return Response({"count": Notification.objects.filter(user=request.user, read__isnull=True).count()})
+
+    @action(methods=["PATCH"], detail=False)
+    def read_all(self, request: Request, pk=None) -> Response:
+        self.get_queryset().filter(read__isnull=True).update(read=timezone.now())
+        return Response({})
+
+    @action(methods=["PATCH"], detail=False)
+    def delete_all_read(self, request: Request, pk=None) -> Response:
+        self.get_queryset().filter(read__isnull=False).delete()
+        return Response({})

wbcore/contrib/pandas/fields.py

@@ -0,0 +1,172 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import List, Literal
+
+import pandas as pd
+
+from wbcore.serializers.fields.types import DisplayMode
+
+
+@dataclass
+class _BaseField:
+    key: str
+    label: str
+    type: str = None
+    decorators: List = None
+    help_text: str = None
+
+    def to_dict(self):
+        base = {"key": self.key, "label": self.label, "type": self.type}
+        if self.decorators:
+            base["decorators"] = self.decorators
+
+        for _attr in ["help_text", "extra"]:
+            attr = getattr(self, _attr, None)
+            if attr:
+                base[_attr] = attr
+        return base
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return value
+
+
+@dataclass
+class PKField(_BaseField):
+    type: str = "primary_key"
+
+
+@dataclass
+class CharField(_BaseField):
+    type: str = "text"
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("string", errors="ignore")
+
+
+@dataclass
+class DateTimeField(_BaseField):
+    type: str = "datetime"
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return pd.to_datetime(super().to_representation(value)).dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+@dataclass
+class DateField(_BaseField):
+    type: str = "date"
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return pd.to_datetime(super().to_representation(value)).dt.strftime("%Y-%m-%d")
+
+
+@dataclass
+class DateRangeField(_BaseField):
+    type: str = "daterange"
+
+
+@dataclass
+class BooleanField(_BaseField):
+    type: str = "boolean"
+
+
+@dataclass
+class TextField(_BaseField):
+    type: str = "texteditor"
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("string", errors="ignore")
+
+
+@dataclass
+class EmojiRatingField(_BaseField):
+    type: str = "emojirating"
+
+
+@dataclass
+class FloatField(_BaseField):
+    type: str = "number"
+    precision: int = 2
+    percent: bool = False
+    display_mode: DisplayMode = None
+    disable_formatting: bool = False
+
+    def to_dict(self):
+        base = super().to_dict()
+        base.update(
+            {
+                "precision": self.precision,
+            }
+        )
+        if self.percent:
+            base["type"] = "percent"
+        if self.display_mode:
+            base["display_mode"] = self.display_mode.value
+        base["disable_formatting"] = self.disable_formatting
+        return base
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("float", errors="ignore")
+
+
+@dataclass
+class IntegerField(FloatField):
+    type: str = "number"
+    precision: int = 0
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).astype("Int64", errors="ignore")
+
+
+@dataclass
+class YearField(IntegerField):
+    precision: int = 0
+    disable_formatting: bool = True
+
+    def __post_init__(self):
+        self.precision = 0
+
+
+@dataclass
+class ListField(_BaseField):
+    type: str = "list"
+
+
+@dataclass
+class JsonField(_BaseField):
+    type: str = "json"
+
+
+@dataclass
+class SparklineField(ListField):
+    type: str = "sparkline"
+    dimension: Literal["single"] | Literal["double"] = (
+        "single"  # "single" for data [y1, y2, y3... ] or "double" if contain already the X axis as [[x1, y1], [x2, y2], ... ]
+    )
+
+    def to_dict(self):
+        rv = super().to_dict()
+        rv["sparkline_type"] = "bar"
+        return rv
+
+    def _sanitize_row(self, row):
+        if not row:
+            row = [[]]  # if row is [] or null, we default to an empty list of list
+        if self.dimension == "single":  # This ensure that the returned data format contains a list of tuple of x,y
+            row = list(map(lambda o: (o[0], o[1]), enumerate(row)))
+        return row
+
+    def to_representation(self, value: pd.Series) -> pd.Series:
+        return super().to_representation(value).apply(lambda x: self._sanitize_row(x))
+
+
+@dataclass(unsafe_hash=True)
+class PandasFields:
+    fields: List[_BaseField]
+
+    def to_dict(self):
+        fields = defaultdict(dict)
+
+        for field in self.fields:
+            fields[field.key] = field.to_dict()
+
+        return fields

wbcore/contrib/pandas/filters.py

@@ -0,0 +1,118 @@
+"""
+Provide Filters for Pandas based views
+"""
+
+import operator
+from functools import reduce
+
+from rest_framework.filters import OrderingFilter, SearchFilter
+
+from wbcore import filters as wb_filters
+from wbcore.filters import DjangoFilterBackend
+from wbcore.filters.utils import check_required_filters
+
+
+class PandasDjangoFilterBackend(DjangoFilterBackend):
+    lookups_operator = {
+        "lte": operator.le,
+        "lt": operator.lt,
+        "gte": operator.ge,
+        "gt": operator.gt,
+        "exact": operator.eq,
+    }
+
+    def filter_queryset(self, request, queryset, view):
+        filterset_class = self.get_filterset_class(view, queryset)
+        if filterset_class and callable(filterset_class):
+            kwargs = self.get_filterset_kwargs(request, queryset, view)
+            filterset = filterset_class(**kwargs)
+            if filterset.is_valid():
+                check_required_filters(request, view, filterset)
+        return super().filter_queryset(request, queryset, view)
+
+    def filter_dataframe(self, request, df, view):
+        if not df.empty:
+            filterset_class = self.get_filterset_class(view, view.get_queryset())
+            if filterset_class and callable(filterset_class):
+                kwargs = self.get_filterset_kwargs(request, view.get_queryset(), view)
+                filter_terms = filterset_class(**kwargs).form.data
+                conditions = []
+                for filter_term, value in filter_terms.items():
+                    if _filter := getattr(filterset_class.Meta, "df_fields", {}).get(filter_term, None):
+                        # We support only number for now
+                        lookup_expr = getattr(_filter, "lookup_expr", "exact")
+                        if isinstance(_filter, wb_filters.NumberFilter):
+                            try:
+                                conditions.append(
+                                    self.lookups_operator[lookup_expr](
+                                        df[_filter.field_name],
+                                        float(value) if not _filter.percent else float(value) / 100,
+                                    )
+                                )
+                            except ValueError:
+                                pass
+                if conditions:
+                    df = df[reduce(operator.and_, conditions)]
+        return df
+
+
+class PandasSearchFilter(SearchFilter):
+    def filter_queryset(self, request, queryset, view):
+        return queryset
+
+    def filter_dataframe(self, request, df, view):
+        search_fields = self.get_search_fields(view, request)
+        search_terms = self.get_search_terms(request)
+        search_fields = [field for field in search_fields if field in df.columns]
+
+        if not search_fields or not search_terms or df.empty:
+            return df
+
+        conditions = []
+
+        for search_term in search_terms:
+            queries = [
+                df[field].str.contains(search_term, na=False, case=False, regex=False) for field in search_fields
+            ]
+            conditions.append(reduce(operator.or_, queries))
+
+        df = df[reduce(operator.and_, conditions)]
+
+        return df
+
+
+class PandasOrderingFilter(OrderingFilter):
+    def get_ordering(self, request, df, view) -> tuple[list[str], list[bool]]:
+        """
+        Ordering is set by a comma delimited ?ordering=... query parameter.
+
+        The `ordering` query parameter can be overridden by setting
+        the `ordering_param` value on the OrderingFilter or by
+        specifying an `ORDERING_PARAM` value in the API settings.
+        """
+        params = request.query_params.get(self.ordering_param)
+        base_ordering_fields = view.get_ordering_fields()
+        potential_ordering_fields = params.split(",") if params else self.get_default_ordering(view)
+        ordering_res = []
+        ascending_res = []
+        if potential_ordering_fields:
+            for ordering_field in potential_ordering_fields:
+                ordering_field = ordering_field.strip()
+                ascending = True
+                if ordering_field.startswith("-"):
+                    ordering_field = ordering_field[1:]
+                    ascending = False
+
+                if ordering_field in df.columns and ordering_field in base_ordering_fields:
+                    ordering_res.append(ordering_field)
+                    ascending_res.append(ascending)
+        return ordering_res, ascending_res
+
+    def filter_queryset(self, request, queryset, view):
+        return queryset
+
+    def filter_dataframe(self, request, df, view):
+        ordering_by, ascending_list = self.get_ordering(request, df, view)
+        if ordering_by and ascending_list:
+            df.sort_values(by=list(ordering_by), ascending=list(ascending_list), inplace=True)
+        return df

wbcore/contrib/pandas/filterset.py

@@ -0,0 +1,28 @@
+from django.core.exceptions import FieldError
+from django.db import models
+
+
+class PandasFilterSetMixin:
+    def filter_queryset(self, queryset):
+        """
+        Filter the queryset with the underlying form's `cleaned_data`. You must
+        call `is_valid()` or `errors` before calling this method.
+
+        This method should be overridden if additional filtering needs to be
+        applied to the queryset before it is cached.
+        """
+        for name, value in self.form.cleaned_data.items():
+            try:
+                queryset = self.filters[name].filter(queryset, value)
+            except FieldError:
+                pass
+            if not isinstance(queryset, models.QuerySet):
+                raise AssertionError(
+                    "Expected '%s.%s' to return a QuerySet, but got a %s instead."
+                    % (
+                        type(self).__name__,
+                        name,
+                        type(queryset).__name__,
+                    )
+                )
+        return queryset

wbcore/contrib/pandas/metadata.py

@@ -0,0 +1,15 @@
+from slugify import slugify
+
+from wbcore.metadata.metadata import WBCoreMetadata
+
+
+class PandasMetadata(WBCoreMetadata):
+    def determine_metadata(self, request, view):
+        metadata = super().determine_metadata(request, view)
+        metadata["identifier"] += f"-{slugify(view.__class__.__name__)}"
+        metadata["fields"] = view.get_pandas_fields(request).to_dict()
+        # if ordering fields is not included in the metadata (e.g. dev didn't explicitly specify a list), then we inject the pandas fields by default
+        # it is safe to do that because for pandas table, the ordering happens on AgGrid
+        if not metadata["ordering_fields"]:
+            metadata["ordering_fields"] = {key: key for key in metadata["fields"].keys()}
+        return metadata

wbcore/contrib/pandas/tests/test_base.py

@@ -0,0 +1,22 @@
+from wbcore.test.mixins import TestViewSet
+from wbcore.test.utils import get_or_create_superuser
+
+
+class TestPandasView(TestViewSet):
+    def test_get_request(self):
+        if self.factory is None:
+            self._raise_warning_factory("test_get_request")
+        else:
+            obj, request, kwargs, _ = self._get_mixins_data()
+            request.user = get_or_create_superuser()
+            request.query_params = dict()
+            request.parser_context = {}
+            self.mvs.kwargs = kwargs
+            response = self.mvs.as_view({"get": "list"})(request, **kwargs)
+            assert response.status_code == 200
+            assert "results" in response.data
+            assert "aggregates" in response.data
+            assert "messages" in response.data
+
+    def execute_test(self):
+        self.test_get_request()

wbcore/contrib/pandas/tests/test_fields/test_number_fields.py

@@ -0,0 +1,19 @@
+import pytest
+
+from wbcore.contrib.pandas.fields import YearField as PandasYearField
+
+
+class TestPandasYearField:
+    @pytest.mark.parametrize(
+        (
+            "key",
+            "label",
+        ),
+        [
+            ("Foo", "Bar"),
+        ],
+    )
+    def test_pandas_year_field_values(self, key, label):
+        field = PandasYearField(key=key, label=label, precision=2)
+        representation = field.to_dict()
+        assert representation["precision"] == 0