wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/notifications/tests/test_serializers/test_notification_types.py

@@ -0,0 +1,59 @@
+import pytest
+from rest_framework.reverse import reverse
+
+from wbcore.contrib.notifications.serializers import (
+    NotificationTypeRepresentationSerializer,
+    NotificationTypeSettingModelSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestNotificationTypeRepresentationSerializer:
+    def test_serialize_instance(self, notification_type):
+        serializer = NotificationTypeRepresentationSerializer(notification_type)
+        assert serializer.data == {
+            "id": notification_type.id,
+            "code": notification_type.code,
+            "title": notification_type.title,
+            "help_text": notification_type.help_text,
+        }
+
+
+@pytest.mark.django_db
+class TestNotificationTypeSettingModelSerializer:
+    def test_serialize_instance(self, notification_type_setting, request_with_user):
+        # We need to add the help_text here manually - we assume the queryset passed into the serializer annotates it
+        # in the viewset.
+        notification_type_setting.help_text = notification_type_setting.notification_type.help_text
+        serializer = NotificationTypeSettingModelSerializer(
+            notification_type_setting, context={"request": request_with_user}
+        )
+
+        assert serializer.data == {
+            "id": notification_type_setting.id,
+            "notification_type": notification_type_setting.notification_type.id,
+            "_notification_type": NotificationTypeRepresentationSerializer(
+                notification_type_setting.notification_type
+            ).data,
+            "help_text": notification_type_setting.notification_type.help_text,
+            "user": notification_type_setting.user.id,
+            "enable_web": notification_type_setting.enable_web,
+            "enable_mobile": notification_type_setting.enable_mobile,
+            "enable_email": notification_type_setting.enable_email,
+            "_additional_resources": {},
+            "_update_url": reverse(
+                "wbcore:notifications:notification_type_setting-list", args=[], request=request_with_user
+            ),
+            "locked_icon": None,
+        }
+
+    def test_deserialize_partial_instance(self, notification_type_setting, request_with_user):
+        serializer = NotificationTypeSettingModelSerializer(
+            notification_type_setting,
+            data={"enable_web": True},
+            partial=True,
+            context={"request": request_with_user},
+        )
+
+        assert serializer.is_valid()
+        assert serializer.validated_data["enable_web"]  # type: ignore

wbcore/contrib/notifications/tests/test_serializers/test_notifications.py

@@ -0,0 +1,24 @@
+import pytest
+
+from wbcore.contrib.notifications.serializers import (
+    NotificationModelSerializer,
+    NotificationTypeRepresentationSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestNotificationModelSerializer:
+    def test_serialize_instance(self, notification, request_with_user):
+        serializer = NotificationModelSerializer(notification, context={"request": request_with_user})
+        assert serializer.data == {
+            "id": notification.id,
+            "title": notification.title,
+            "notification_type": notification.notification_type.id,
+            "_notification_type": NotificationTypeRepresentationSerializer(notification.notification_type).data,
+            "body": notification.body,
+            "user": notification.user.pk,
+            "endpoint": notification.endpoint,
+            "sent": notification.sent,
+            "read": notification.read,
+            "_additional_resources": {},
+        }

wbcore/contrib/notifications/tests/test_tasks.py

@@ -0,0 +1,72 @@
+import pytest
+from bs4 import BeautifulSoup
+from django.core import mail
+from django.test.utils import override_settings
+
+from wbcore.contrib.notifications import tasks
+
+
+@pytest.fixture
+def patched_send_notification_email(mocker):
+    return mocker.patch("wbcore.contrib.notifications.tasks.send_notification_email")
+
+
+@pytest.fixture
+def patched_import_string(mocker):
+    return mocker.patch("wbcore.contrib.notifications.tasks.import_string")
+
+
+@pytest.fixture
+def mock_backend():
+    from wbcore.contrib.notifications.backends.abstract_backend import (
+        AbstractNotificationBackend,
+    )
+
+    class MockedBackend(AbstractNotificationBackend):
+        @classmethod
+        def send_notification(cls, notification):
+            pass
+
+        @classmethod
+        def get_configuration(cls) -> dict:
+            return {}
+
+    return MockedBackend
+
+
+@pytest.mark.django_db
+def test_send_notification_task(
+    notification, mock_backend, mocker, patched_send_notification_email, patched_import_string
+):
+    notification.user.wbnotification_user_settings.update(enable_email=True)
+    spy = mocker.spy(mock_backend, "send_notification")
+    patched_import_string.return_value = mock_backend
+
+    tasks.send_notification_task(notification.pk)
+
+    patched_send_notification_email.assert_called_once_with(notification)
+    patched_import_string.assert_called_once()
+    spy.assert_called_once_with(notification)
+
+
+@pytest.mark.django_db
+def test_send_notification_task_without_mail(
+    notification, mock_backend, patched_send_notification_email, patched_import_string
+):
+    notification.user.wbnotification_user_settings.update(enable_email=False)
+    patched_import_string.return_value = mock_backend
+
+    tasks.send_notification_task(notification.pk)
+
+    assert not patched_send_notification_email.called
+
+
+@pytest.mark.django_db
+@override_settings(EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend")
+@pytest.mark.parametrize("notification__endpoint", ["/wbcore/notifications/"])
+def test_send_notification_email(notification):
+    assert len(mail.outbox) == 0
+    tasks.send_notification_email(notification)
+    assert len(mail.outbox) == 1
+    soup = BeautifulSoup(mail.outbox[0].alternatives[0][0], "html.parser")
+    assert soup.find("a", href=notification.get_full_endpoint(as_shareable_internal_link=True))

wbcore/contrib/notifications/tests/test_viewsets/test_notification_types.py

@@ -0,0 +1,120 @@
+import pytest
+from rest_framework.reverse import reverse
+
+from wbcore.contrib.authentication.factories import InternalUserFactory, UserFactory
+from wbcore.contrib.notifications.factories.notification_types import (
+    NotificationTypeModelFactory,
+)
+
+
+@pytest.mark.django_db
+class TestNotificationTypeRepresentationViewSet:
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.select_notificationtype"], 200)]
+    )
+    def test_instance(self, notification_type, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(
+            reverse("wbcore:notifications:notification_type_representation-detail", args=[notification_type.pk])
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.select_notificationtype"], 200)]
+    )
+    def test_list(self, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification_type_representation-list"))
+        assert response.status_code == status_code  # type: ignore
+
+
+@pytest.mark.django_db
+class TestNotificationTypeSettingModelViewSet:
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.view_notificationtypesetting"], 200)]
+    )
+    def test_instance(self, notification_type_setting, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.pk])
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.view_notificationtypesetting"], 200)]
+    )
+    def test_list(self, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification_type_setting-list"))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.add_notificationtypesetting"], 403)]
+    )
+    def test_create(self, notification_type, client, user, status_code):
+        """Regardless of permission, no user should ever be able to create notification type setting"""
+        client.force_authenticate(user)
+        response = client.post(
+            reverse("wbcore:notifications:notification_type_setting-list"),
+            {"user": user.id, "notification_type": notification_type.id},
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.delete_notificationtypesetting"], 403)]
+    )
+    def test_delete(self, notification_type_setting, client, user, status_code):
+        """Regardless of permission, no user should ever be able to delete notification type setting"""
+        client.force_authenticate(user)
+        response = client.delete(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id])
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(None, 403), (["notifications.change_notificationtypesetting"], 200)]
+    )
+    def test_change(self, notification_type_setting, client, user, status_code):
+        notification_type_setting.user = user
+        notification_type_setting.save()
+
+        client.force_authenticate(user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id]),
+            {"enable_web": True},
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(["notifications.change_notificationtypesetting"], 200)]
+    )
+    def test_change_notification_type_and_user(self, notification_type_setting, client, user, status_code):
+        """Regardless of the permission, you should never be able to change the user or notification type"""
+        user2 = UserFactory()
+        notification_type2 = NotificationTypeModelFactory()
+
+        assert user != user2
+        assert notification_type_setting.notification_type != notification_type2
+
+        client.force_authenticate(user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id]),
+            {"notification_type": notification_type2.pk, "user": user2.pk},  # type: ignore
+        )
+        assert response.status_code == status_code  # type: ignore
+        assert response.data["instance"]["user"] == user.pk
+        assert response.data["instance"]["notification_type"] == notification_type_setting.notification_type.pk
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code", [(["notifications.change_notificationtypesetting"], 404)]
+    )
+    def test_change_setting_from_other_user(self, notification_type_setting, client, user, status_code):
+        """Regardless of permission, no user should ever be able to change a setting from a different user"""
+        other_user = InternalUserFactory(is_superuser=True)
+
+        client.force_authenticate(other_user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification_type_setting-detail", args=[notification_type_setting.id]),
+            {"enable_web": True},
+        )
+        assert response.status_code == status_code  # type: ignore

wbcore/contrib/notifications/tests/test_viewsets/test_notifications.py

@@ -0,0 +1,143 @@
+import pytest
+from django.utils import timezone
+from rest_framework.reverse import reverse
+
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.notifications.factories.notifications import (
+    NotificationModelFactory,
+)
+from wbcore.contrib.notifications.models.notifications import Notification
+
+
+@pytest.mark.django_db
+class TestNotificationModelViewSet:
+    @pytest.mark.parametrize(
+        "user__user_permissions, status_code",
+        [(None, 403), (["notifications.view_notification"], 200)],
+    )
+    def test_instance(self, notification, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code",
+        [(["notifications.view_notification"], 200)],
+    )
+    def test_instance_read(self, notification, client, user, status_code):
+        assert notification.read is None
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+        notification.refresh_from_db()
+        assert notification.read is not None
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code",
+        [(None, 403), (["notifications.view_notification"], 200)],
+    )
+    def test_list(self, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.get(reverse("wbcore:notifications:notification-list"))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code",
+        [(["notifications.add_notification"], 403)],
+    )
+    def test_create(self, notification, client, user, status_code):
+        """Regardless of permission, no user should ever be able to create notification"""
+        client.force_authenticate(user)
+        response = client.post(
+            reverse("wbcore:notifications:notification-list"),
+            {
+                "user": user.id,
+                "notification": notification.id,
+                "title": "abc",
+                "body": "abc",
+            },
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code",
+        [(["notifications.change_notification"], 403)],
+    )
+    def test_change(self, notification, client, user, status_code):
+        """Regardless of permission, no user should ever be able to change notification"""
+        client.force_authenticate(user)
+        response = client.patch(
+            reverse("wbcore:notifications:notification-detail", args=[notification.pk]),
+            {"title": "abc"},
+        )
+        assert response.status_code == status_code  # type: ignore
+        response = client.put(
+            reverse("wbcore:notifications:notification-detail", args=[notification.pk]),
+            {"title": "abc"},
+        )
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code",
+        [(None, 403), (["notifications.delete_notification"], 204)],
+    )
+    def test_delete(self, notification, client, user, status_code):
+        client.force_authenticate(user)
+        response = client.delete(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize(
+        "user__user_permissions,status_code",
+        [(["notifications.delete_notification"], 404)],
+    )
+    def test_delete_other_notification(self, notification, client, user, status_code):
+        """Regardless of the permission, a user should never be able to delete another users notifications"""
+        user2 = UserFactory()
+        notification.user = user2
+        notification.save()
+        client.force_authenticate(user)
+        response = client.delete(reverse("wbcore:notifications:notification-detail", args=[notification.pk]))
+        assert response.status_code == status_code  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_read_all_action(self, notification, client, user):
+        assert notification.read is None
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-read-all"))
+        notification.refresh_from_db()
+        assert notification.read is not None
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_read_all_action_other_notification(self, notification, client, user):
+        notification2 = NotificationModelFactory()
+        assert notification.read is None
+        assert notification2.read is None  # type: ignore
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-read-all"))
+        notification.refresh_from_db()
+        notification2.refresh_from_db()  # type: ignore
+        assert notification.read is not None
+        assert notification2.read is None  # type: ignore
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_delete_all_action(self, notification, client, user):
+        NotificationModelFactory(user=user, read=timezone.now())
+        assert Notification.objects.filter(user=user).count() == 2
+
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-delete-all-read"))
+
+        assert Notification.objects.filter(user=user).count() == 1
+
+    @pytest.mark.parametrize("user__user_permissions", [(["notifications.change_notification"])])
+    def test_delete_all_action_other_notification(self, notification, client, user):
+        user2 = UserFactory()
+        NotificationModelFactory(user=user2, read=timezone.now())
+        notification.read = timezone.now()
+        notification.save()
+        assert Notification.objects.all().count() == 2
+
+        client.force_authenticate(user)
+        client.patch(reverse("wbcore:notifications:notification-delete-all-read"))
+
+        assert Notification.objects.all().count() == 1

wbcore/contrib/notifications/urls.py

@@ -0,0 +1,27 @@
+from django.urls import include, path
+
+from wbcore.contrib.notifications import viewsets
+from wbcore.contrib.notifications.views import (
+    NotificationTokenAPIView,
+    service_worker_view,
+)
+from wbcore.routers import WBCoreRouter
+
+router = WBCoreRouter()
+
+router.register("notification", viewsets.NotificationModelViewSet, basename="notification")
+router.register(
+    "notification_type_representation",
+    viewsets.NotificationTypeRepresentationViewSet,
+    basename="notification_type_representation",
+)
+router.register(
+    "notification_type_setting", viewsets.NotificationTypeSettingModelViewSet, basename="notification_type_setting"
+)
+
+
+urlpatterns = [
+    path("service-worker/<str:service_worker_name>", service_worker_view, name="service-worker"),
+    path("token/", NotificationTokenAPIView.as_view(), name="token"),
+    path("", include(router.urls)),
+]

wbcore/contrib/notifications/utils.py

@@ -0,0 +1,27 @@
+from django.conf import settings
+from django.contrib.sites.models import Site
+
+
+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 create_notification_type(
+    code: str,
+    title: str,
+    help_text: str,
+    web: bool = True,
+    mobile: bool = True,
+    email: bool = False,
+    resource_button_label: str = "",
+    is_lock: bool = False,  # set to true if user cannot modified the preference for this notification type
+) -> tuple[str, str, str, bool, bool, bool, str, bool]:
+    return (code, title, help_text, web, mobile, email, resource_button_label, is_lock)

wbcore/contrib/notifications/views.py

@@ -0,0 +1,63 @@
+from django.conf import settings
+from django.contrib.staticfiles import finders
+from django.db.utils import IntegrityError
+from django.http.response import HttpResponse
+from django.utils.module_loading import import_string
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from wbcore.contrib.notifications.models.tokens import NotificationUserToken
+
+
+class NotificationTokenAPIView(APIView):
+    """An APIView that returns the configuration needed for a frontend to generate a token and to upload said token"""
+
+    permission_classes = [IsAuthenticated]
+
+    def get(self, request: Request) -> Response:
+        return Response(import_string(settings.NOTIFICATION_BACKEND).get_configuration())
+
+    def post(self, request: Request) -> Response:
+        try:
+            token: str = request.data["token"]  # type: ignore
+
+            existing_instance = NotificationUserToken.objects.filter(
+                user=request.user,
+                token__startswith=token.split(":")[0],
+            )
+
+            if existing_instance.exists():
+                existing_instance.update(token=token)
+            else:
+                NotificationUserToken.objects.create(
+                    user=request.user,
+                    token=token,
+                    device_type=request.data["device_type"],  # type: ignore
+                )
+            return Response({}, status=status.HTTP_201_CREATED)
+        except IntegrityError:
+            return Response({}, status=status.HTTP_200_OK)
+        except KeyError:
+            return Response({}, status=status.HTTP_400_BAD_REQUEST)
+
+    def delete(self, request: Request) -> Response:
+        queryset = NotificationUserToken.objects.filter(user=request.user)
+
+        if device_type := request.GET.get("device_type", None):  # type: ignore
+            queryset = queryset.filter(device_type=device_type)
+
+        queryset.delete()
+        return Response({}, status=status.HTTP_204_NO_CONTENT)
+
+
+def service_worker_view(request, service_worker_name: str | None = None):
+    file_path = finders.find(f"notifications/{service_worker_name}")
+    if file_path:
+        with open(file_path) as f:
+            response = HttpResponse(content=f.read(), content_type="application/javascript")
+            response.headers["Service-Worker-Allowed"] = "../" * ((request.get_full_path()).count("/") - 1)
+            return response
+    return HttpResponse(status=status.HTTP_400_BAD_REQUEST)

wbcore/contrib/notifications/viewsets/__init__.py

@@ -0,0 +1,5 @@
+from .notification_types import (
+    NotificationTypeRepresentationViewSet,
+    NotificationTypeSettingModelViewSet,
+)
+from .notifications import NotificationModelViewSet

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

@@ -0,0 +1,49 @@
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import Unit
+from wbcore.metadata.configs.display import Field, Legend, LegendItem, 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
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class NotificationTypeSettingDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> ListDisplay:
+        return ListDisplay(
+            fields=[
+                Field(key="locked_icon", label=" ", width=Unit.PIXEL(40)),
+                Field(key="notification_type", label="Notification", width=Unit.PIXEL(250)),
+                Field(key="help_text", label="Help Text", width=Unit.PIXEL(500)),
+                Field(key="enable_web", label="Web", width=Unit.PIXEL(100)),
+                Field(key="enable_mobile", label="Mobile", width=Unit.PIXEL(100)),
+                Field(key="enable_email", label="E-Mail", width=Unit.PIXEL(100)),
+            ],
+            legends=[
+                Legend(
+                    items=[
+                        LegendItem(
+                            icon=WBIcon.LOCK.icon,
+                            label="Locked",
+                        ),
+                    ],
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["notification_type", "notification_type", "notification_type"],
+                ["enable_web", "enable_mobile", "enable_email"],
+            ]
+        )
+
+
+class NotificationTypeSettingEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None
+
+    def get_update_endpoint(self):
+        return "{{_update_url}}"