wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/io/viewset_mixins.py

@@ -0,0 +1,301 @@
+from contextlib import suppress
+from typing import Any
+
+import tablib
+from django.conf import settings
+from django.core.exceptions import PermissionDenied
+from django.dispatch import receiver
+from django.http import HttpResponse
+from django.utils.functional import cached_property
+from django.utils.translation import gettext as _
+from import_export.admin import ImportExportMixin
+from import_export.signals import post_export
+from rest_framework import status
+from rest_framework.authentication import SessionAuthentication
+from rest_framework.decorators import action, parser_classes
+from rest_framework.exceptions import ParseError
+from rest_framework.parsers import MultiPartParser
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from wbcore import serializers
+from wbcore.contrib.authentication.authentication import JWTCookieAuthentication
+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 create_simple_display
+from wbcore.signals.instance_buttons import add_extra_button
+
+from .enums import ExportFormat, get_django_import_export_format
+from .resources import ViewResource
+from .utils import get_import_export_identifier, parse_endpoint
+
+
+class ImportFileSerializer(serializers.Serializer):
+    file = serializers.FileField()
+
+
+class ExportFileSerializer(serializers.Serializer):
+    format = serializers.ChoiceField(choices=ExportFormat.choices, label="Format", required=True)
+
+
+class ImportExportDRFMixin(ImportExportMixin):
+    """
+    This mixin can be imported to enable import export out of the box. This will add two action to import a file given its extension
+    or Export the filtered queryset content as a file
+    """
+
+    IMPORT_ALLOWED: bool = False  # by default import is disabled and requires an explicit defined resource
+    EXPORT_ALLOWED: bool = True
+
+    @cached_property
+    def model(self):
+        try:
+            return getattr(self.queryset, "model", None)
+        except AttributeError:
+            raise ParseError("Malformed Queryset")
+
+    @cached_property
+    def opts(self):
+        return self.model._meta
+
+    @cached_property
+    def export_pagination_limit(self) -> int:
+        return getattr(
+            settings, "WBIMPORT_EXPORT_DEFAULT_EXPORT_PAGINATION_LIMIT", settings.REST_FRAMEWORK.get("page_size", 25)
+        )
+
+    def get_resource_class(self) -> type:
+        """
+        This function returns return the resource class to use. Default to the model resource factory on the queryset model
+        """
+        return ViewResource
+
+    def get_import_filter_kwargs(self, request):
+        return dict()
+
+    def _get_resource_serializer_class(self):
+        with suppress(AttributeError, AssertionError):
+            return self.get_serializer_class()
+
+    def get_resource_kwargs(self, request, *args, **kwargs) -> dict[str, Any]:
+        """
+        This method is called during the import workflow to inject permanent field into the import. By default, it injects
+        all the view kwargs
+
+        Args:
+            request: The ongoing request
+
+        Returns:
+            A dictionary of permanent field
+        """
+        return {
+            "request": request,
+            "serializer_class": self._get_resource_serializer_class(),
+            "columns_map": ViewResource.get_columns_map(self),
+            **self.kwargs,
+        }
+
+    def _get_data_for_export(self, request, queryset, *args, **kwargs) -> tablib.Dataset:
+        raise NotImplementedError()
+
+    def has_import_permission(self, request) -> bool:
+        """
+        called by the import workflow to determine if a user can import data
+
+        Can be overriden if custom behavior is necessary
+        """
+        return self.IMPORT_ALLOWED and request and super().has_import_permission(request) and "pk" not in self.kwargs
+
+    def has_export_permission(self, request) -> bool:
+        """
+        called by the import workflow to determine if a user can export data
+
+        Can be overriden if custom behavior is necessary
+        """
+        return self.EXPORT_ALLOWED and request and super().has_export_permission(request) and "pk" not in self.kwargs
+
+    @action(
+        detail=False,
+        methods=["PATCH"],
+        permission_classes=[IsAuthenticated],
+        authentication_classes=[SessionAuthentication, JWTCookieAuthentication],
+        url_name="processimport",
+    )
+    @parser_classes([MultiPartParser])
+    def process_import(self, request, **kwargs):
+        """
+        This action parse a file and trigger the import workflow from its dataset
+        """
+        if not self.has_import_permission(request):
+            raise PermissionDenied
+        if request.data:
+            if (file_tmp := request.FILES.get("file")) and (resource_class := self.get_resource_class()):
+                from wbcore.contrib.io.models import (  # for circular dependency. Will fix later
+                    ImportSource,
+                    ParserHandler,
+                    import_data_as_task,
+                )
+
+                parser_handler, _ = ParserHandler.objects.get_or_create(
+                    handler=f"{self.model._meta.app_label}.{self.model.__name__}", parser=resource_class.__module__
+                )
+                import_source = ImportSource.objects.create(
+                    parser_handler=parser_handler, file=file_tmp, origin="Internal Import", creator=request.user
+                )
+                import_data_as_task.delay(import_source.id)
+
+                return HttpResponse("Your file will be imported shortly", status=status.HTTP_200_OK)
+        return HttpResponse("Not all expected parameter were provided", status=status.HTTP_400_BAD_REQUEST)
+
+    @action(
+        detail=False,
+        methods=["PATCH"],
+        permission_classes=[IsAuthenticated],
+        authentication_classes=[JWTCookieAuthentication],
+        url_name="processexport",
+    )
+    def process_export(self, request, **kwargs):
+        """
+        This action export a queryset into a file
+        """
+        if not self.has_export_permission(request):
+            raise PermissionDenied
+        if (export_format := int(request.data.get("format", -1))) is not None and export_format in ExportFormat.values:
+            queryset = self.filter_queryset(self.get_queryset())
+            if queryset.exists():
+                from wbcore.contrib.io.models import ExportSource
+
+                # The export job is too big and needs to be ran asynchronously
+                try:
+                    export_data = self._get_data_for_export(request, queryset, **kwargs)
+                    _data = [list(row) for row in export_data._data]
+
+                    ExportSource.objects.create(
+                        creator=request.user,
+                        format=export_format,
+                        content_type=self.get_content_type(),
+                        data={"data": _data, "headers": export_data.headers},
+                    )
+                except NotImplementedError:
+                    resource_kwargs = {
+                        "columns_map": ViewResource.get_columns_map(self),
+                    }
+                    if resource_serializer_class := self._get_resource_serializer_class():
+                        resource_kwargs["serializer_class_path"] = (
+                            resource_serializer_class.__module__ + "." + resource_serializer_class.__name__
+                        )
+                    resource_class = self.get_resource_class()
+                    query_str, query_params = queryset.query.sql_with_params()
+
+                    ExportSource.objects.create(
+                        creator=request.user,
+                        format=export_format,
+                        content_type=self.get_content_type(),
+                        resource_path=resource_class.__module__ + "." + resource_class.__name__,
+                        resource_kwargs=resource_kwargs,
+                        query_str=query_str,
+                        query_params=query_params,
+                    )
+                return Response("export job created", status=status.HTTP_200_OK)
+        return HttpResponse("Not all expected parameter were provided", status=status.HTTP_400_BAD_REQUEST)
+
+    @action(
+        detail=False,
+        methods=["GET"],
+        permission_classes=[IsAuthenticated],
+        authentication_classes=[SessionAuthentication, JWTCookieAuthentication],
+        url_name="exporttemplate",
+    )
+    def export_template(self, request, **kwargs):
+        """
+        This action export a template into a file
+        """
+        if (
+            export_format := int(request.GET.get("export_format", -1))
+        ) is not None and export_format in ExportFormat.values:
+            file_format = get_django_import_export_format()[export_format]()
+            export_data = self.get_export_data(file_format, None, request=request, encoding=self.to_encoding, **kwargs)
+            content_type = file_format.get_content_type()
+            response = HttpResponse(export_data, content_type=content_type)
+            response["Content-Disposition"] = 'attachment; filename="%s"' % (
+                self.get_export_filename(request, None, file_format),
+            )
+            post_export.send(sender=None, model=self.model)
+            return response
+
+
+@receiver(add_extra_button)
+def add_template_extra_button(sender, instance, request, view, pk=None, **kwargs):
+    if (
+        view
+        and not instance
+        and not view.inline
+        and hasattr(view, "has_import_permission")
+        and view.has_import_permission(request)
+    ):
+        buttons = []
+        for format in ExportFormat:
+            buttons.append(
+                bt.HyperlinkButton(
+                    endpoint=parse_endpoint(request, "export_template", export_format=format.value),
+                    title=format.label,
+                    label=format.label,
+                )
+            )
+        if buttons:
+            return bt.DropDownButton(
+                title=_("Templates"),
+                label=_("Templates"),
+                icon=WBIcon.UPLOAD.icon,
+                buttons=tuple(buttons),
+                weight=2,
+            )
+
+
+@receiver(add_extra_button)
+def add_import_extra_button(sender, instance, request, view, pk=None, **kwargs):
+    if (
+        view
+        and not instance
+        and not view.inline
+        and hasattr(view, "has_import_permission")
+        and view.has_import_permission(request)
+        and view.get_resource_class()
+    ):
+        return bt.ActionButton(
+            method=RequestType.PATCH,
+            icon=WBIcon.DOWNLOAD.icon,
+            identifiers=(get_import_export_identifier(view),),
+            endpoint=parse_endpoint(request, "process_import"),
+            action_label=_("Import"),
+            title=_("Import"),
+            label=_("Import"),
+            description_fields=_("Please provide a valid CSV file (Coma Separated Value)"),
+            serializer=ImportFileSerializer,
+            instance_display=create_simple_display([["file"]]),
+            weight=0,
+        )
+
+
+@receiver(add_extra_button)
+def add_export_extra_button(sender, instance, request, view, pk=None, **kwargs):
+    if (
+        view
+        and not instance
+        and not view.inline
+        and hasattr(view, "has_export_permission")
+        and view.has_export_permission(request)
+    ):
+        return bt.ActionButton(
+            method=RequestType.PATCH,
+            icon=WBIcon.DOWNLOAD.icon,
+            identifiers=(get_import_export_identifier(view),),
+            endpoint=parse_endpoint(request, "process_export"),
+            action_label=_("Export"),
+            title=_("Export"),
+            label=_("Export"),
+            description_fields=_("Select the export format"),
+            serializer=ExportFileSerializer,
+            instance_display=create_simple_display([["format"]]),
+            weight=1,
+        )

wbcore/contrib/io/viewsets.py

@@ -0,0 +1,138 @@
+import json
+
+import tablib
+from wbcore.pandas import fields as pf
+from wbcore.pandas.views import PandasAPIViewSet
+from wbcore.viewsets import ModelViewSet, ReadOnlyModelViewSet, RepresentationViewSet
+
+from .configs.endpoints import (
+    ImportSourceModelViewSetEndpointConfig,
+    SourceModelViewSetEndpointConfig,
+)
+from .models import DataBackend, ImportSource, ParserHandler, Source
+from .resources import ViewResource
+from .serializers import (
+    DataBackendRepresentationSerializer,
+    ImportSourceModelSerializer,
+    ImportSourceRepresentationSerializer,
+    ParserHandlerModelSerializer,
+    ParserHandlerRepresentationSerializer,
+    SourceModelSerializer,
+    SourceRepresentationSerializer,
+)
+from .viewset_mixins import ImportExportDRFMixin
+
+
+class ImportSourceRepresentationViewSet(RepresentationViewSet):
+    ordering = ["id"]
+    queryset = ImportSource.objects.all()
+    serializer_class = ImportSourceRepresentationSerializer
+
+
+class SourceRepresentationViewSet(RepresentationViewSet):
+    ordering = ["id"]
+    search_fields = ["id", "title"]
+    filterset_fields = {"title": ["exact", "icontains"], "id": ["in", "exact"]}
+    queryset = Source.objects.all()
+    serializer_class = SourceRepresentationSerializer
+
+
+class ParserHandlerRepresentationViewSet(RepresentationViewSet):
+    ordering = ["parser", "handler", "id"]
+    search_fields = ["parser", "handler"]
+    filterset_fields = {
+        "parser": ["exact", "icontains"],
+        "handler": ["exact", "icontains"],
+    }
+    queryset = ParserHandler.objects.all()
+    serializer_class = ParserHandlerRepresentationSerializer
+
+
+class DataBackendRepresentationViewSet(RepresentationViewSet):
+    ordering = ["title", "id"]
+    search_fields = ["title"]
+    filterset_fields = {
+        "title": ["exact", "icontains"],
+        "backend_class_path": ["exact", "icontains"],
+    }
+    queryset = DataBackend.objects.all()
+    serializer_class = DataBackendRepresentationSerializer
+
+
+class ParserHandlerModelViewSet(ModelViewSet):
+    ordering = ["parser", "handler", "id"]
+    search_fields = ["parser", "handler"]
+    filterset_fields = {
+        "parser": ["exact", "icontains"],
+        "handler": ["exact", "icontains"],
+    }
+    queryset = ParserHandler.objects.all()
+    serializer_class = ParserHandlerModelSerializer
+
+
+class ImportSourceModelViewSet(ModelViewSet):
+    ordering = ["id"]
+    search_fields = ["parser_handler__parser", "parser_handler__handler"]
+    filterset_fields = {
+        "parser_handler": ["exact"],
+        "status": ["exact"],
+        "source": ["exact"],
+        "creator": ["exact"],
+        "created": ["lte", "gte"],
+        "last_updated": ["lte", "gte"],
+    }
+    queryset = ImportSource.objects.all()
+    serializer_class = ImportSourceModelSerializer
+    endpoint_config_class = ImportSourceModelViewSetEndpointConfig
+
+
+class SourceModelViewSet(ReadOnlyModelViewSet):
+    ordering = ["id"]
+    search_fields = ["parser_handler__parser", "parser_handler__handler", "title", "uuid", "data_backend__title"]
+    filterset_fields = {
+        "title": ["icontains"],
+        "uuid": ["exact"],
+        "parser_handler": ["exact"],
+        "is_active": ["exact"],
+        "data_backend": ["exact"],
+    }
+    queryset = Source.objects.all()
+    serializer_class = SourceModelSerializer
+    endpoint_config_class = SourceModelViewSetEndpointConfig
+    lookup_field = "uuid"
+
+
+class ExportPandasAPIViewSet(ImportExportDRFMixin, PandasAPIViewSet):
+    IMPORT_ALLOWED: bool = False
+
+    def _get_validated_headers(self, request, df) -> list[str]:
+        """
+        This method validates the available columns and their ability to serialize
+        """
+        validated_headers = []
+        pandas_fields = {f.key: f for f in self.get_pandas_fields(request).fields}
+        for col in df.columns:
+            if (pdf := pandas_fields.get(col, None)) and not isinstance(
+                pdf, pf.SparklineField
+            ):  # exclude sparkeline from exported data
+                validated_headers.append(pdf.key)
+        return validated_headers
+
+    def _get_data_for_export(self, request, queryset, *args, **kwargs) -> tablib.Dataset:
+        df = self._get_dataframe(export=True, **kwargs)
+        validated_headers = self._get_validated_headers(request, df)
+        df = df[
+            df.columns.intersection(validated_headers)
+        ]  # ensure df contains only the validated header, in that specific order
+
+        columns_map = ViewResource.get_columns_map(self)
+        dataset = tablib.Dataset(headers=list(columns_map.values()))
+        df = json.loads(
+            df.to_json(orient="records", date_format="iso")
+        )  # we do that do ensure that dataframe values have be converted to json friendly data
+        for data in df:
+            row = []
+            for key in columns_map.keys():  # Ensure data is appended to the row in the header order
+                row.append(data.get(key, None))
+            dataset.append(row)
+        return dataset

wbcore/contrib/notifications/admin.py

@@ -0,0 +1,61 @@
+from datetime import date, timedelta
+
+from django.contrib import admin
+from wbcore.contrib.notifications.tasks import send_notification_task
+
+from .models import (
+    Notification,
+    NotificationType,
+    NotificationTypeSetting,
+    NotificationUserToken,
+)
+
+
+@admin.register(Notification)
+class NotificationModelAdmin(admin.ModelAdmin):
+    search_fields = ["title", "body"]
+
+    list_display = [
+        "title",
+        "user",
+        "notification_type",
+        "endpoint",
+        "sent",
+        "read",
+    ]
+
+    @admin.action(description="Send Notification")
+    def send_notification(self, request, queryset):
+        for notification in queryset:
+            send_notification_task.delay(notification.id)
+
+    actions = [send_notification]
+
+
+@admin.register(NotificationUserToken)
+class NotificationUserTokenModelAdmin(admin.ModelAdmin):
+    list_display = ("user", "token", "device_type", "updated")
+
+    @admin.action(description="Remove all stale tokens")
+    def remove_stale_tokens(self, request, queryset):
+        cutoff_date = date.today() - timedelta(days=60)
+        queryset.filter(updated__date__lte=cutoff_date).delete()
+
+    actions = [remove_stale_tokens]
+
+
+@admin.register(NotificationTypeSetting)
+class NotificationTypeSettingModelAdmin(admin.ModelAdmin):
+    list_display = ("notification_type", "user", "enable_web", "enable_mobile", "enable_email")
+
+
+@admin.register(NotificationType)
+class NotificationTypeModelAdmin(admin.ModelAdmin):
+    list_display = (
+        "code",
+        "title",
+        "contenttype",
+        "default_enable_web",
+        "default_enable_mobile",
+        "default_enable_email",
+    )

wbcore/contrib/notifications/apps.py

@@ -0,0 +1,38 @@
+from django.apps import AppConfig
+from django.db import DEFAULT_DB_ALIAS
+from django.db.models.signals import post_migrate
+
+
+def notification_type_post_migrate(app_config, using=DEFAULT_DB_ALIAS, **kwargs):
+    from django.contrib.contenttypes.models import ContentType
+    from wbcore.contrib.notifications.models import NotificationType
+
+    ContentType.objects.clear_cache()
+    # For each model in an app, generate all notification types listed in the meta class of each model
+    for klass in app_config.get_models():
+        # Get the contenttype and set all notification types for this content type to stale
+        # All "touched" notification types will be automatically set to stale=False
+        contenttype = ContentType.objects.db_manager(using).get_for_model(klass, for_concrete_model=False)  # type: ignore
+        NotificationType.objects.db_manager(using).filter(contenttype=contenttype).update(stale=True)
+
+        for code, title, help_text, web, mobile, email in getattr(klass._meta, "notification_types", []):
+            NotificationType.objects.using(using).update_or_create(
+                code=code,
+                defaults={
+                    "contenttype": contenttype,
+                    "title": title,
+                    "help_text": help_text,
+                    "default_enable_web": web,
+                    "default_enable_mobile": mobile,
+                    "default_enable_email": email,
+                    "stale": False,
+                },
+            )
+
+
+class NotificationsConfig(AppConfig):
+    default_auto_field = "django.db.models.AutoField"
+    name = "wbcore.contrib.notifications"
+
+    def ready(self):
+        post_migrate.connect(notification_type_post_migrate)

wbcore/contrib/notifications/backends/abstract_backend.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractclassmethod
+
+from wbcore.contrib.notifications.models import Notification
+
+
+class AbstractNotificationBackend(ABC):
+    @abstractclassmethod
+    def send_notification(cls, notification: Notification):
+        ...
+
+    @abstractclassmethod
+    def get_configuration(cls) -> dict:
+        ...

wbcore/contrib/notifications/backends/console/__init__.py

@@ -0,0 +1 @@
+from .backends import NotificationBackend

wbcore/contrib/notifications/backends/console/backends.py

@@ -0,0 +1,25 @@
+import sys
+import threading
+from contextlib import suppress
+
+from ..abstract_backend import AbstractNotificationBackend
+
+
+class NotificationBackend(AbstractNotificationBackend):
+    @classmethod
+    def send_notification(cls, notification):
+        """Write the notification to the stream in a thread-safe way."""
+
+        _lock = threading.RLock()
+        stream = sys.stdout
+        with _lock:
+            with suppress(Exception):
+                stream.write("%s\n" % notification.title)
+                stream.write("%s\n" % notification.body or "")
+                stream.write("-" * 79)
+                stream.write("\n")
+                stream.flush()  # flush after each message
+
+    @classmethod
+    def get_configuration(cls) -> dict:
+        return {}

wbcore/contrib/notifications/backends/firebase/__init__.py

@@ -0,0 +1 @@
+from .backends import NotificationBackend