wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/notifications/models/notifications.py

@@ -0,0 +1,82 @@
+import urllib
+from contextlib import suppress
+
+from django.contrib.auth import get_user_model
+from django.core.validators import URLValidator, ValidationError
+from django.db import models
+from django.urls import Resolver404, resolve
+from django.utils.functional import cached_property
+
+from wbcore.contrib.notifications.utils import base_domain, create_notification_type
+
+
+class Notification(models.Model):
+    title = models.CharField(max_length=255)
+    body = models.TextField(null=True, blank=True)
+
+    user = models.ForeignKey(to=get_user_model(), related_name="notifications_notifications", on_delete=models.CASCADE)
+    notification_type = models.ForeignKey(
+        to="notifications.NotificationType", related_name="notifications", on_delete=models.CASCADE
+    )
+    endpoint = models.CharField(max_length=2048, null=True, blank=True)
+
+    created = models.DateTimeField(auto_now_add=True)
+    sent = models.DateTimeField(null=True, blank=True)
+    read = models.DateTimeField(null=True, blank=True)
+
+    def __str__(self) -> str:
+        return f"{self.user} {self.title}"
+
+    class Meta:
+        verbose_name = "Notification"
+        verbose_name_plural = "Notifications"
+
+        notification_types = [
+            create_notification_type(
+                "workbench.system",
+                "System Notifications",
+                "System Notifications.",
+                True,
+                True,
+                False,
+            ),
+        ]
+
+    @cached_property
+    def is_endpoint_internal(self) -> bool:
+        with suppress(Resolver404):
+            if self.endpoint:
+                resolve(
+                    urllib.parse.urlsplit(urllib.parse.unquote(self.endpoint)).path
+                )  # we need to truncate query parameters
+                return True
+        return False
+
+    @cached_property
+    def is_endpoint_valid(self) -> bool:
+        try:
+            URLValidator()(self.endpoint)
+            return True
+        except ValidationError:
+            return False
+
+    def get_full_endpoint(self, as_shareable_internal_link: bool = False) -> str | None:
+        if self.is_endpoint_internal:
+            if as_shareable_internal_link:
+                return f"{base_domain()}?widget_endpoint={self.endpoint}"
+            else:
+                return f"{base_domain()}{self.endpoint}"
+        elif self.is_endpoint_valid:
+            return self.endpoint
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbcore:notifications:notification"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{title}}"

wbcore/contrib/notifications/models/tokens.py

@@ -0,0 +1,46 @@
+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,51 @@
+from rest_framework.reverse import reverse
+
+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()
+    locked_icon = serializers.IconSelectField(read_only=True)
+    locked = serializers.BooleanField(read_only=True)
+    _update_url = serializers.SerializerMethodField()
+
+    def get__update_url(self, obj):
+        if not obj.notification_type.is_lock:
+            return reverse(
+                "wbcore:notifications:notification_type_setting-list", args=[], request=self.context["request"]
+            )
+        return None
+
+    class Meta:
+        read_only_fields = ("user", "notification_type", "help_text")
+        model = NotificationTypeSetting
+        fields = (
+            "id",
+            "notification_type",
+            "_notification_type",
+            "help_text",
+            "user",
+            "enable_web",
+            "enable_mobile",
+            "enable_email",
+            "locked",
+            "locked_icon",
+            "_additional_resources",
+            "_update_url",
+        )

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/static/notifications/service-worker.js

@@ -0,0 +1 @@
+function a0_0x4393(){const _0x57af5e=['816WHdKTb','body','initializeApp','[101,121,74,104,99,71,108,76,90,88,107,105,79,105,74,66,83,88,112,104,85,51,108,69,98,86,100,52,89,88,100,119,78,69,104,120,86,110,108,52,99,48,104,52,85,108,70,88,77,87,119,53,86,51,70,77,85,110,74,112,99,70,90,89,77,71,115,105,76,67,74,104,100,88,82,111,82,71,57,116,89,87,108,117,73,106,111,105,100,50,57,121,97,50,74,108,98,109,78,111,76,88,78,48,89,87,108,117,98,72,107,117,90,109,108,121,90,87,74,104,99,50,86,104,99,72,65,117,89,50,57,116,73,105,119,105,99,72,74,118,97,109,86,106,100,69,108,107,73,106,111,105,100,50,57,121,97,50,74,108,98,109,78,111,76,88,78,48,89,87,108,117,98,72,107,105,76,67,74,122,100,71,57,121,89,87,100,108,81,110,86,106,97,50,86,48,73,106,111,105,100,50,57,121,97,50,74,108,98,109,78,111,76,88,78,48,89,87,108,117,98,72,107,117,89,88,66,119,99,51,66,118,100,67,53,106,98,50,48,105,76,67,74,116,90,88,78,122,89,87,100,112,98,109,100,84,90,87,53,107,90,88,74,74,90,67,73,54,73,106,81,49,78,106,69,53,79,68,103,49,77,68,77,49,77,105,73,115,73,109,70,119,99,69,108,107,73,106,111,105,77,84,111,48,78,84,89,120,79,84,103,52,78,84,65,122,78,84,73,54,100,50,86,105,79,109,90,104,89,87,73,120,90,68,82,106,90,68,78,109,89,106,100,109,78,122,65,51,89,84,90,104,90,106,85,105,76,67,74,116,90,87,70,122,100,88,74,108,98,87,86,117,100,69,108,107,73,106,111,105,82,121,49,88,78,107,52,51,78,106,89,51,78,69,82,76,73,110,48,61]','find','focus','origin','notificationclick','https://www.gstatic.com/firebasejs/9.22.0/firebase-messaging-compat.js','/?widget_endpoint=','waitUntil','title','window','openWindow','2928488LdzTTp','false','https://www.gstatic.com/firebasejs/9.22.0/firebase-app-compat.js','notification','is_endpoint_internal','close','9347456hpzmwS','url','HANDLE_NOTIFICATION','2095ejcNAP','3666918SdTsTm','497VBfvBu','parse','onBackgroundMessage','2684wPivrd','showNotification','data','location','3973545Klehgi','decode','endpoint','542235lhCfqf'];a0_0x4393=function(){return _0x57af5e;};return a0_0x4393();}function a0_0x3412(_0x3e53c1,_0x48472e){const _0x439370=a0_0x4393();return a0_0x3412=function(_0x3412c6,_0x54b59f){_0x3412c6=_0x3412c6-0x156;let _0x3fb5d8=_0x439370[_0x3412c6];return _0x3fb5d8;},a0_0x3412(_0x3e53c1,_0x48472e);}(function(_0x35e4fd,_0x10da15){const _0x7c8df9=a0_0x3412,_0x3a8c24=_0x35e4fd();while(!![]){try{const _0xb925b3=parseInt(_0x7c8df9(0x164))/0x1+-parseInt(_0x7c8df9(0x173))/0x2+parseInt(_0x7c8df9(0x159))/0x3+-parseInt(_0x7c8df9(0x15d))/0x4*(parseInt(_0x7c8df9(0x158))/0x5)+parseInt(_0x7c8df9(0x165))/0x6*(parseInt(_0x7c8df9(0x15a))/0x7)+parseInt(_0x7c8df9(0x179))/0x8+-parseInt(_0x7c8df9(0x161))/0x9;if(_0xb925b3===_0x10da15)break;else _0x3a8c24['push'](_0x3a8c24['shift']());}catch(_0x23d016){_0x3a8c24['push'](_0x3a8c24['shift']());}}}(a0_0x4393,0xb8813),((()=>{const _0x3232c0=a0_0x3412;var _0x36e6f1={};importScripts(_0x3232c0(0x175)),importScripts(_0x3232c0(0x16d));const _0x100673=_0x3232c0(0x168),_0x5107be=new Uint8Array(JSON[_0x3232c0(0x15b)](_0x100673)),_0x56e78c=new TextDecoder(),_0x63139d=_0x56e78c[_0x3232c0(0x162)](_0x5107be),_0x467794=JSON[_0x3232c0(0x15b)](atob(_0x63139d)),_0x3d92ff=firebase[_0x3232c0(0x167)](_0x467794),_0x21f609=firebase['messaging'](_0x3d92ff);_0x21f609[_0x3232c0(0x15c)](_0x2180f1=>{const _0x366f43=_0x3232c0;var _0x4972d6,_0xfb3e9b;const {data:_0x2e4b1c}=_0x2180f1,_0x2aae25=(_0x4972d6=_0x2e4b1c==null?void 0x0:_0x2e4b1c[_0x366f43(0x170)])!=null?_0x4972d6:'',_0x277939={'body':(_0xfb3e9b=_0x2e4b1c==null?void 0x0:_0x2e4b1c[_0x366f43(0x166)])!=null?_0xfb3e9b:'','icon':'https://stainly-cdn.fra1.cdn.digitaloceanspaces.com/media%2Flogo_orange.svg','data':{'endpoint':_0x2e4b1c==null?void 0x0:_0x2e4b1c[_0x366f43(0x163)],'is_endpoint_internal':_0x2e4b1c==null?void 0x0:_0x2e4b1c[_0x366f43(0x177)]}};return self['registration'][_0x366f43(0x15e)](_0x2aae25,_0x277939);}),self['addEventListener'](_0x3232c0(0x16c),_0x541ced=>{const _0x2767d9=_0x3232c0;var _0x47b9e3,_0x21a538;_0x541ced['notification'][_0x2767d9(0x178)]();const _0x4b09fb=((_0x47b9e3=_0x541ced[_0x2767d9(0x176)]['data'])==null?void 0x0:_0x47b9e3['endpoint'])||'',_0x48f331=(_0x21a538=_0x541ced[_0x2767d9(0x176)][_0x2767d9(0x15f)])==null?void 0x0:_0x21a538[_0x2767d9(0x177)],{origin:_0xda61ed}=self[_0x2767d9(0x160)];_0x541ced[_0x2767d9(0x16f)](((async()=>{const _0x30d532=_0x2767d9,_0x2cc1d4=await clients['matchAll']({'type':_0x30d532(0x171),'includeUncontrolled':!![]}),_0x16e94d=_0x2cc1d4[_0x30d532(0x169)](_0x44d3d3=>new URL(_0x44d3d3[_0x30d532(0x156)])[_0x30d532(0x16b)]===_0xda61ed&&_0x30d532(0x16a)in _0x44d3d3);if(_0x16e94d)return _0x16e94d['postMessage']({'type':_0x30d532(0x157),'endpoint':_0x4b09fb,'is_endpoint_internal':_0x48f331}),_0x16e94d[_0x30d532(0x16a)]();else{if(clients[_0x30d532(0x172)])return clients[_0x30d532(0x172)](_0x48f331===_0x30d532(0x174)?_0x4b09fb:new URL(_0x4b09fb)[_0x30d532(0x16b)]+_0x30d532(0x16e)+encodeURIComponent(_0x4b09fb));}})()));});})()));

wbcore/contrib/notifications/tasks.py

@@ -0,0 +1,57 @@
+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
+from wbcore.workers import Queue
+
+
+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(queue=Queue.HIGH_PRIORITY.value)
+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/templates/notifications/notification_template.html

@@ -0,0 +1,43 @@
+{% extends "wbcore/email_base_template.html" %}
+{% load i18n %}
+{% block body %}
+<tr class="content-row">
+    <td style="background-color: #eaf2ff;"></td>
+    <td class="body-content">
+        <p>
+            <b>{{ title }}</b>
+        </p>
+    </td>
+    <td style="background-color: #eaf2ff;"></td>
+</tr>
+<tr class="content-row">
+    <td style="background-color: #eaf2ff;"></td>
+    <td class="body-content">
+        {{ message | safe}}
+    </td>
+    <td style="background-color: #eaf2ff;"></td>
+</tr>
+{% if notification_share_url %}
+<tr class="content-row">
+    <td style="background-color: #eaf2ff;"></td>
+    <td class="body-content">
+        <table cellspacing="0" cellpadding="0">
+            <tr>
+                <td style="border-radius: 10px;" bgcolor="#f76f5b">
+                    <a class="link" href="{{ notification_share_url }}" target="_blank" style="padding: 8px 12px; border: 1px solid #ED2939; border-radius: 10px;font-family: Helvetica, Arial, sans-serif;font-size: 14px; color: #ffffff;text-decoration: none;font-weight:bold;display: inline-block;">
+                        {% translate "Open" %}
+                    </a>
+                </td>
+            </tr>
+        </table>
+    </td>
+    <td style="background-color: #eaf2ff;"></td>
+</tr>
+<tr>
+    <td style="background-color: #eaf2ff;"></td>
+    <td class="body-content">
+    </td>
+    <td style="background-color: #eaf2ff;"></td>
+</tr>
+{% endif %}
+{% endblock %}

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,79 @@
+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,85 @@
+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,46 @@
+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,30 @@
+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 setting.enable_web is False
+        assert setting.enable_mobile is False
+        assert not NotificationUserToken.objects.filter_for_user_settings(setting).exists()
+
+        setting.enable_web = True
+        setting.enable_mobile = True
+        setting.save()
+
+        assert NotificationUserToken.objects.filter_for_user_settings(setting).first() == notification_user_token  # type: ignore