wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/notifications/models/tokens.py

@@ -0,0 +1,45 @@
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.db.models.query import QuerySet
+from wbcore.contrib.notifications.models.notification_types import (
+    NotificationTypeSetting,
+)
+
+
+class NotificationUserTokenManager(models.Manager):
+    def filter_for_user_settings(self, user_setting: NotificationTypeSetting) -> QuerySet["NotificationUserToken"]:
+        device_type = NotificationUserToken.NotificationDeviceType
+        device_types = []
+
+        if user_setting.enable_web:
+            device_types.append(device_type.WEB)
+
+        if user_setting.enable_mobile:
+            device_types.append(device_type.MOBILE)
+
+        return self.filter(
+            user=user_setting.user,
+            device_type__in=device_types,
+        )
+
+
+class NotificationUserToken(models.Model):
+    class NotificationDeviceType(models.TextChoices):
+        WEB = "WEB", "Web"
+        MOBILE = "MOBILE", "Mobile"
+
+    user = models.ForeignKey(to=get_user_model(), related_name="notifications_tokens", on_delete=models.CASCADE)
+    token = models.CharField(max_length=256)
+    device_type = models.CharField(max_length=16, choices=NotificationDeviceType.choices)
+
+    updated = models.DateTimeField(auto_now=True)
+
+    objects = NotificationUserTokenManager()
+
+    def __str__(self) -> str:
+        return f"{self.user}: {self.token} ({self.device_type})"
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(fields=["user", "token", "device_type"], name="unique_user_token_device")
+        ]

wbcore/contrib/notifications/release_notes/1_0_0.md

@@ -0,0 +1,13 @@
+Date: 2023-04-26
+Module: Notification
+Summary: Initial Release Note
+Version: 1.0.0
+
+## New Features
+- Bootstrap module versioning
+
+## Enhancements
+./.
+
+## Bugfixes
+./.

wbcore/contrib/notifications/serializers/__init__.py

@@ -0,0 +1,5 @@
+from .notification_types import (
+    NotificationTypeRepresentationSerializer,
+    NotificationTypeSettingModelSerializer,
+)
+from .notifications import NotificationModelSerializer

wbcore/contrib/notifications/serializers/notification_types.py

@@ -0,0 +1,36 @@
+from wbcore import serializers
+from wbcore.contrib.notifications.models import (
+    NotificationType,
+    NotificationTypeSetting,
+)
+
+
+class NotificationTypeRepresentationSerializer(serializers.RepresentationSerializer):
+    class Meta:
+        model = NotificationType
+        fields = (
+            "id",
+            "code",
+            "title",
+            "help_text",
+        )
+
+
+class NotificationTypeSettingModelSerializer(serializers.ModelSerializer):
+    _notification_type = NotificationTypeRepresentationSerializer(source="notification_type")
+    help_text = serializers.CharField()
+
+    class Meta:
+        read_only_fields = ("user", "notification_type")
+        model = NotificationTypeSetting
+        fields = (
+            "id",
+            "notification_type",
+            "_notification_type",
+            "help_text",
+            "user",
+            "enable_web",
+            "enable_mobile",
+            "enable_email",
+            "_additional_resources",
+        )

wbcore/contrib/notifications/serializers/notifications.py

@@ -0,0 +1,33 @@
+from wbcore import serializers
+from wbcore.contrib.notifications.models import Notification
+from wbcore.contrib.notifications.serializers.notification_types import (
+    NotificationTypeRepresentationSerializer,
+)
+
+
+class NotificationModelSerializer(serializers.ModelSerializer):
+    _notification_type = NotificationTypeRepresentationSerializer(source="notification_type")
+
+    @serializers.register_resource()
+    def register_buttons(self, instance, request, user) -> dict[str, str]:
+        if endpoint := instance.endpoint:
+            if instance.is_endpoint_internal:
+                return {"open_internal_resource": endpoint}
+            else:
+                return {"open_external_resource": endpoint}
+        return {}
+
+    class Meta:
+        model = Notification
+        fields = read_only_fields = (
+            "id",
+            "notification_type",
+            "_notification_type",
+            "title",
+            "body",
+            "user",
+            "endpoint",
+            "sent",
+            "read",
+            "_additional_resources",
+        )

wbcore/contrib/notifications/tasks.py

@@ -0,0 +1,55 @@
+from celery import shared_task
+from django.conf import settings
+from django.core.mail.message import EmailMultiAlternatives
+from django.template.loader import get_template
+from django.utils.html import strip_tags
+from django.utils.module_loading import import_string
+from wbcore.contrib.notifications.models.notification_types import (
+    NotificationTypeSetting,
+)
+from wbcore.contrib.notifications.models.notifications import Notification
+
+
+def send_notification_email(notification: Notification):
+    """Sends out a notification to the user specified inside the notification
+
+    Args:
+        notification: The notification that is going to be send
+    """
+
+    context = {
+        "title": notification.title,
+        "message": notification.body or "",
+        "notification_share_url": notification.get_full_endpoint(as_shareable_internal_link=True),
+        "notification_endpoint": notification.get_full_endpoint(),
+    }
+    rendered_template = get_template("notifications/notification_template.html").render(context)
+    msg = EmailMultiAlternatives(
+        subject=notification.title,
+        body=strip_tags(rendered_template),
+        from_email=getattr(settings, "WBCORE_NOTIFICATION_EMAIL_FROM", "no_reply@stainly.com"),
+        to=[notification.user.email],  # type: ignore
+    )
+    msg.attach_alternative(rendered_template, "text/html")
+    msg.send()
+
+
+@shared_task
+def send_notification_task(notification_pk: int):
+    """A celery task to send out a notification via email, web or mobile
+
+    Args:
+        notification_pk: The primary key of the notification that is going to be send out
+    """
+
+    notification = Notification.objects.get(pk=notification_pk)
+
+    notification_user_settings = NotificationTypeSetting.objects.get(
+        notification_type=notification.notification_type,
+        user=notification.user,
+    )
+    if notification_user_settings.enable_email:
+        send_notification_email(notification)
+
+    backend = import_string(settings.NOTIFICATION_BACKEND)
+    backend.send_notification(notification)

wbcore/contrib/notifications/tests/conftest.py

@@ -0,0 +1,47 @@
+import pytest
+from pytest_factoryboy import register
+from rest_framework.test import APIClient, APIRequestFactory
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.contrib.notifications.factories.notification_types import (
+    NotificationTypeModelFactory,
+    NotificationTypeSettingModelFactory,
+)
+from wbcore.contrib.notifications.factories.notifications import (
+    NotificationModelFactory,
+)
+from wbcore.contrib.notifications.factories.tokens import (
+    NotificationUserTokenModelFactory,
+)
+from wbcore.tests.conftest import *
+
+register(UserFactory)
+register(PersonFactory)
+register(NotificationTypeModelFactory, name="notification_type")
+register(NotificationTypeSettingModelFactory, name="notification_type_setting")
+register(NotificationModelFactory, name="notification")
+register(NotificationUserTokenModelFactory, name="notification_user_token")
+
+
+@pytest.fixture
+def request_with_user(user):
+    request = APIRequestFactory().get("/")
+    request.user = user
+    return request
+
+
+@pytest.fixture
+def client():
+    return APIClient()
+
+
+@pytest.fixture(
+    autouse=True, scope="session"
+)  # Might want to find a way to registered default conftest logic automatically
+def django_test_environment(django_test_environment):
+    from django.apps import apps
+
+    get_models = apps.get_models
+
+    for m in [m for m in get_models() if not m._meta.managed]:
+        m._meta.managed = True

wbcore/contrib/notifications/tests/test_backends/test_firebase.py

@@ -0,0 +1,78 @@
+import pytest
+from wbcore.contrib.notifications.backends.firebase.backends import (
+    NotificationBackend as FirebaseNotificationBackend,
+)
+from wbcore.contrib.notifications.factories.tokens import (
+    NotificationUserTokenModelFactory,
+)
+from wbcore.contrib.notifications.models.tokens import NotificationUserToken
+
+
+@pytest.mark.django_db
+def test_send_notification(mocker, notification, user):
+    mocked_get_app = mocker.patch(
+        "wbcore.contrib.notifications.backends.firebase.backends.firebase_admin.get_app",
+    )
+    mocked_initialize_app = mocker.patch(
+        "wbcore.contrib.notifications.backends.firebase.backends.firebase_admin.initialize_app",
+    )
+    mocked_send = mocker.patch("wbcore.contrib.notifications.backends.firebase.backends.messaging.send")
+    mocked_get_firebase_credentials = mocker.patch.object(FirebaseNotificationBackend, "get_firebase_credentials")
+
+    NotificationUserTokenModelFactory.create(user=user, device_type=NotificationUserToken.NotificationDeviceType.WEB)
+    notification.notification_type.user_settings.filter(user=notification.user).update(enable_web=True)
+    FirebaseNotificationBackend.send_notification(notification)
+
+    mocked_send.assert_called_once()
+    mocked_get_firebase_credentials.assert_called_once()
+    mocked_get_app.assert_called_once()
+    mocked_initialize_app.assert_not_called()
+
+
+@pytest.mark.django_db
+def test_send_multiple_notifications(mocker, notification, user):
+    mocked_get_app = mocker.patch(
+        "wbcore.contrib.notifications.backends.firebase.backends.firebase_admin.get_app",
+    )
+    mocked_initialize_app = mocker.patch(
+        "wbcore.contrib.notifications.backends.firebase.backends.firebase_admin.initialize_app",
+    )
+    mocked_send = mocker.patch("wbcore.contrib.notifications.backends.firebase.backends.messaging.send")
+    mocked_get_firebase_credentials = mocker.patch.object(FirebaseNotificationBackend, "get_firebase_credentials")
+
+    NotificationUserTokenModelFactory.create_batch(
+        3, user=user, device_type=NotificationUserToken.NotificationDeviceType.WEB
+    )
+    notification.notification_type.user_settings.filter(user=notification.user).update(enable_web=True)
+    FirebaseNotificationBackend.send_notification(notification)
+
+    assert mocked_send.call_count == 3
+    mocked_get_firebase_credentials.assert_called_once()
+    mocked_get_app.assert_called_once()
+    mocked_initialize_app.assert_not_called()
+
+
+@pytest.mark.django_db
+def test_send_notification_with_initialize(mocker, notification, user):
+    mocked_get_app = mocker.patch(
+        "wbcore.contrib.notifications.backends.firebase.backends.firebase_admin.get_app",
+        side_effect=ValueError(),
+    )
+    mocked_initialize_app = mocker.patch(
+        "wbcore.contrib.notifications.backends.firebase.backends.firebase_admin.initialize_app"
+    )
+    mocked_send = mocker.patch("wbcore.contrib.notifications.backends.firebase.backends.messaging.send")
+    mocked_get_firebase_credentials = mocker.patch.object(FirebaseNotificationBackend, "get_firebase_credentials")
+    NotificationUserTokenModelFactory.create(user=user, device_type=NotificationUserToken.NotificationDeviceType.WEB)
+    notification.notification_type.user_settings.filter(user=notification.user).update(enable_web=True)
+    FirebaseNotificationBackend.send_notification(notification)
+
+    mocked_get_app.assert_called_once()
+    mocked_initialize_app.assert_called_once()
+    mocked_send.assert_called_once()
+    mocked_get_firebase_credentials.assert_called_once()
+
+
+def test_get_configuration(mocker):
+    mocker.patch.dict("os.environ", {"FIREBASE_WEB_CONFIG": '{"ABC": "123"}', "FIREBASE_VAPID_KEY": "DEF"})
+    assert FirebaseNotificationBackend.get_configuration() == {"firebase_config": {"ABC": "123"}, "vapid_key": "DEF"}

wbcore/contrib/notifications/tests/test_configs.py

@@ -0,0 +1,7 @@
+from wbcore.configs.registry import ConfigRegistry
+
+
+def test_notifications_config(config_registry: ConfigRegistry):
+    notifications = config_registry.get_config_dict()["notifications"]
+    assert notifications["endpoint"]
+    assert notifications["token"]

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

@@ -0,0 +1,84 @@
+import pytest
+from django.db.utils import IntegrityError
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.notifications.factories.notification_types import (
+    NotificationTypeModelFactory,
+)
+from wbcore.contrib.notifications.models import (
+    NotificationType,
+    NotificationTypeSetting,
+)
+
+
+@pytest.mark.django_db
+class TestNotificationType:
+    def test_factory(self, notification_type: NotificationType):
+        assert isinstance(notification_type, NotificationType)
+        assert notification_type.pk is not None
+
+    def test_to_str(self, notification_type: NotificationType):
+        assert str(notification_type) == notification_type.title
+
+    def test_endpoint_basename(self):
+        assert NotificationType.get_endpoint_basename() == "wbcore:notifications:notification_type"
+
+    def test_representation_endpoint(self):
+        assert (
+            NotificationType.get_representation_endpoint()
+            == "wbcore:notifications:notification_type_representation-list"
+        )
+
+    def test_representation_value_key(self):
+        assert NotificationType.get_representation_value_key() == "id"
+
+    def test_representation_label_key(self):
+        assert NotificationType.get_representation_label_key() == "{{title}}"
+
+    @pytest.mark.parametrize("notification_type__code", ["code"])
+    def test_unique_code(self, notification_type: NotificationType):
+        assert notification_type.pk is not None
+
+        with pytest.raises(IntegrityError):
+            NotificationTypeModelFactory(code="code")
+
+
+@pytest.mark.django_db
+class TestNotificationTypeSetting:
+    def test_factory(self, notification_type_setting: NotificationTypeSetting):
+        assert isinstance(notification_type_setting, NotificationTypeSetting)
+        assert notification_type_setting.pk is not None
+
+    def test_to_str(self, notification_type_setting: NotificationTypeSetting):
+        template = "{0.user}: {0.notification_type} ({0.enable_web}/{0.enable_mobile}/{0.enable_email})"
+        assert str(notification_type_setting) == template.format(notification_type_setting)
+
+    def test_endpoint_basename(self):
+        assert NotificationTypeSetting.get_endpoint_basename() == "wbcore:notifications:notification_type_setting"
+
+    def test_representation_endpoint(self):
+        assert (
+            NotificationTypeSetting.get_representation_endpoint()
+            == "wbcore:notifications:notification_type_setting_representation-list"
+        )
+
+    def test_representation_value_key(self):
+        assert NotificationTypeSetting.get_representation_value_key() == "id"
+
+    def test_representation_label_key(self):
+        assert NotificationTypeSetting.get_representation_label_key() == "{{notification_type}}"
+
+    def test_create_through_post_save_from_notification_type(self, user):
+        assert user.pk is not None
+        type_count = NotificationTypeSetting.objects.filter(user=user).count()
+
+        NotificationTypeModelFactory()
+
+        assert NotificationTypeSetting.objects.filter(user=user).count() == type_count + 1
+
+    def test_create_through_post_save_from_user(self, notification_type):
+        assert notification_type.pk is not None
+        assert not NotificationTypeSetting.objects.filter(notification_type=notification_type).exists()
+
+        UserFactory()
+
+        assert NotificationTypeSetting.objects.filter(notification_type=notification_type).exists()

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

@@ -0,0 +1,45 @@
+import pytest
+from wbcore.contrib.notifications.models import Notification
+from wbcore.contrib.notifications.utils import base_domain
+
+
+@pytest.mark.django_db
+class TestNotification:
+    def test_factory(self, notification: Notification):
+        assert isinstance(notification, Notification)
+        assert notification.pk is not None
+
+    def test_to_str(self, notification: Notification):
+        assert str(notification) == f"{notification.user} {notification.title}"
+
+    def test_endpoint_basename(self):
+        assert Notification.get_endpoint_basename() == "wbcore:notifications:notification"
+
+    def test_representation_value_key(self):
+        assert Notification.get_representation_value_key() == "id"
+
+    def test_representation_label_key(self):
+        assert Notification.get_representation_label_key() == "{{title}}"
+
+    @pytest.mark.parametrize("notification__endpoint", ["/wbcore/notifications/"])
+    def test_full_valid_internal_endpoint(self, notification):
+        assert notification.get_full_endpoint() == f"{base_domain()}{notification.endpoint}"
+
+    @pytest.mark.parametrize("notification__endpoint", ["/some_invalid_namespace/notifications/"])
+    def test_full_invalid_internal_endpoint(self, notification):
+        assert notification.get_full_endpoint() is None
+
+    @pytest.mark.parametrize("notification__endpoint", ["/wbcore/notifications/"])
+    def test_full_internal_endpoint_as_shareable_link(self, notification):
+        assert (
+            notification.get_full_endpoint(as_shareable_internal_link=True)
+            == f"{base_domain()}?widget_endpoint={notification.endpoint}"
+        )
+
+    @pytest.mark.parametrize("notification__endpoint", ["https://www.google.com"])
+    def test_full_valid_external_endpoint(self, notification):
+        assert notification.get_full_endpoint() == notification.endpoint
+
+    @pytest.mark.parametrize("notification__endpoint", ["https.www.google.com"])
+    def test_full_invalid_external_endpoint(self, notification):
+        assert notification.get_full_endpoint() is None

wbcore/contrib/notifications/tests/test_models/test_tokens.py

@@ -0,0 +1,21 @@
+import pytest
+from wbcore.contrib.notifications.factories.notification_types import (
+    NotificationTypeSettingModelFactory,
+)
+from wbcore.contrib.notifications.models import NotificationUserToken
+
+
+@pytest.mark.django_db
+class TestNotificationUserToken:
+    def test_factory(self, notification_user_token: NotificationUserToken):
+        assert isinstance(notification_user_token, NotificationUserToken)
+        assert notification_user_token.pk is not None
+
+    def test_to_str(self, notification_user_token: NotificationUserToken):
+        assert str(notification_user_token) == "{0.user}: {0.token} ({0.device_type})".format(notification_user_token)
+
+    def test_filter_for_settings(self, notification_user_token: NotificationUserToken):
+        setting = NotificationTypeSettingModelFactory(
+            user=notification_user_token.user, enable_web=True, enable_mobile=True
+        )
+        assert NotificationUserToken.objects.filter_for_user_settings(setting).first() == notification_user_token  # type: ignore

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

@@ -0,0 +1,53 @@
+import pytest
+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": {},
+        }
+
+    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,23 @@
+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,71 @@
+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))