wbcore 2.2.1__py2.py3-none-any.whl

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

@@ -0,0 +1,102 @@
+import json
+import os
+
+import firebase_admin
+from django.utils.html import strip_tags
+from firebase_admin import messaging
+from firebase_admin.credentials import Certificate
+from wbcore.contrib.notifications.backends.abstract_backend import (
+    AbstractNotificationBackend,
+)
+from wbcore.contrib.notifications.models import Notification, NotificationUserToken
+from wbcore.contrib.notifications.models.notification_types import (
+    NotificationTypeSetting,
+)
+
+
+class NotificationBackend(AbstractNotificationBackend):
+    FCM_OPTIONS = messaging.FCMOptions(analytics_label="notification")
+
+    @classmethod
+    def get_firebase_app(cls, certificate: Certificate):
+        try:
+            return firebase_admin.get_app()
+        except ValueError:
+            return firebase_admin.initialize_app(certificate)
+
+    @classmethod
+    def get_firebase_credentials(cls):
+        certificate = json.loads(os.environ.get("FIREBASE_SERVICE_WORKER_CREDENTIALS", "{}"))
+        return Certificate(certificate)
+
+    @classmethod
+    def send_notification(cls, notification: Notification):
+        app = cls.get_firebase_app(cls.get_firebase_credentials())
+        notification_user_settings = NotificationTypeSetting.objects.get(
+            notification_type=notification.notification_type,
+            user=notification.user,
+        )
+        tokens = NotificationUserToken.objects.filter_for_user_settings(notification_user_settings)
+        endpoint_data = {}  # Firebase can't accept non-string value
+        if full_endpoint := notification.get_full_endpoint():
+            endpoint_data["endpoint"] = full_endpoint
+        expired_tokens = []
+        for token in tokens.filter(device_type=NotificationUserToken.NotificationDeviceType.MOBILE):
+            message = messaging.Message(
+                notification=messaging.Notification(
+                    title=notification.title,
+                    body=strip_tags(notification.body or ""),
+                ),
+                data=endpoint_data,
+                token=token.token,
+                android=messaging.AndroidConfig(
+                    priority="high",
+                    ttl=3600,
+                    notification=messaging.AndroidNotification(
+                        color="#f45342",
+                        default_sound=True,
+                        visibility="public",
+                        default_vibrate_timings=True,
+                        priority="max",
+                    ),
+                ),
+                apns=messaging.APNSConfig(
+                    payload=messaging.APNSPayload(
+                        aps=messaging.Aps(sound=messaging.CriticalSound("default", volume=1.0))
+                    ),
+                ),
+                fcm_options=cls.FCM_OPTIONS,
+            )
+            try:
+                messaging.send(message, False, app)
+            except messaging.UnregisteredError:
+                expired_tokens.append(token)
+
+        for token in tokens.filter(device_type=NotificationUserToken.NotificationDeviceType.WEB):
+            data = {
+                "title": notification.title,
+                "body": strip_tags(notification.body or ""),
+                "is_endpoint_internal": (
+                    "true" if notification.is_endpoint_internal else "false"
+                ),  # we need the data dictionary to contains only string values, otherwise firebase API complains
+            }
+            data.update(endpoint_data)
+            message = messaging.Message(
+                data=data,
+                token=token.token,
+                fcm_options=cls.FCM_OPTIONS,
+            )
+            try:
+                messaging.send(message, False, app)
+            except messaging.UnregisteredError:
+                expired_tokens.append(token)
+
+        for expired_token in expired_tokens:
+            expired_token.delete()
+
+    @classmethod
+    def get_configuration(cls) -> dict:
+        return {
+            "firebase_config": json.loads(os.environ.get("FIREBASE_WEB_CONFIG", "")),
+            "vapid_key": os.environ.get("FIREBASE_VAPID_KEY", ""),
+        }

wbcore/contrib/notifications/configs.py

@@ -0,0 +1,12 @@
+from rest_framework.request import Request
+from rest_framework.reverse import reverse
+from wbcore.configs.decorators import register_config
+
+
+@register_config
+def notification_config(request: Request) -> tuple[str, dict[str, str]]:
+    return "notifications", {
+        "endpoint": reverse("wbcore:notifications:notification-list", request=request),
+        "token": reverse("wbcore:notifications:token", request=request),
+        "unread_notifications": reverse("wbcore:notifications:notification-unread-count", request=request),
+    }

wbcore/contrib/notifications/configurations.py

@@ -0,0 +1,9 @@
+from configurations import values
+from django.db.models import options
+
+
+class NotificationConfiguration:
+    options.DEFAULT_NAMES = options.DEFAULT_NAMES + ("notification_types",)
+    NOTIFICATION_BACKEND = values.Value(
+        "wbcore.contrib.notifications.backends.firebase.NotificationBackend", environ_prefix=None
+    )

wbcore/contrib/notifications/dispatch.py

@@ -0,0 +1,71 @@
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.db import transaction
+from django.dispatch import receiver
+from django.utils import timezone
+from django.utils.module_loading import import_string
+from django.utils.translation import gettext
+from rest_framework.reverse import reverse
+from wbcore.shares.signals import handle_widget_sharing
+
+from .models import Notification, NotificationType, NotificationTypeSetting
+from .tasks import send_notification_task
+
+User = get_user_model()
+
+
+def send_notification(
+    code: str,
+    title: str,
+    body: str,
+    user: User,
+    reverse_name: str | None = None,
+    reverse_args=None,
+    reverse_kwargs=None,
+    endpoint: str | None = None,
+):
+    """Method for dispatching a notification
+
+    Args:
+        code: The code pointing to a `NotificationType`
+        title: The title of the notification
+        body: The text of the notification
+        user: The user that should receive the notification
+        reverse_name: The reverse name of an endpoint attached to this notification
+        reverse_args: The arguments passed to the `reverse` function
+        reverse_kwargs: The keyword arguments passed to the `reverse` function
+        endpoint: The endpoint of resource. If provided, reverse_name + args + kwargs are disregarded
+    """
+    notification_user_settings = NotificationTypeSetting.objects.filter(
+        notification_type__code=code,
+        user=user,
+    )
+    if user.is_active and notification_user_settings.exists():
+        if not endpoint:
+            endpoint = reverse(reverse_name, reverse_args, reverse_kwargs) if reverse_name else None
+        notification = Notification.objects.create(
+            title=title,
+            body=body,
+            user=user,
+            notification_type=NotificationType.objects.get(code=code),
+            endpoint=endpoint,
+            sent=timezone.now(),
+        )
+        transaction.on_commit(lambda: send_notification_task.delay(notification.pk))
+
+
+@receiver(handle_widget_sharing)
+def share_notification(
+    request, widget_relative_endpoint, share=False, share_message=None, share_recipients=None, **kwargs
+):
+    if share and share_recipients and share_message:
+        for recipient in share_recipients:
+            send_notification(
+                code="workbench.system",
+                title=gettext("{} shared a widget with you").format(
+                    import_string(settings.WBCORE_DEFAULT_USER_NAME)(request.user)
+                ),
+                user=recipient,
+                body=share_message,
+                endpoint=widget_relative_endpoint,
+            )

wbcore/contrib/notifications/factories/notification_types.py

@@ -0,0 +1,22 @@
+import factory
+from wbcore.contrib.notifications.models import (
+    NotificationType,
+    NotificationTypeSetting,
+)
+
+
+class NotificationTypeModelFactory(factory.django.DjangoModelFactory):
+    code = factory.Faker("pystr")
+    title = factory.Faker("pystr")
+    help_text = factory.Faker("pystr")
+
+    class Meta:
+        model = NotificationType
+
+
+class NotificationTypeSettingModelFactory(factory.django.DjangoModelFactory):
+    notification_type = factory.SubFactory(NotificationTypeModelFactory)
+    user = factory.SubFactory("wbcore.contrib.authentication.factories.UserFactory")
+
+    class Meta:
+        model = NotificationTypeSetting

wbcore/contrib/notifications/factories/notifications.py

@@ -0,0 +1,16 @@
+import factory
+from wbcore.contrib.notifications.factories.notification_types import (
+    NotificationTypeModelFactory,
+)
+from wbcore.contrib.notifications.models import Notification
+
+
+class NotificationModelFactory(factory.django.DjangoModelFactory):
+    title = factory.Faker("pystr")
+    body = factory.Faker("pystr")
+    notification_type = factory.SubFactory(NotificationTypeModelFactory)
+    user = factory.SubFactory("wbcore.contrib.authentication.factories.UserFactory")
+    endpoint = None
+
+    class Meta:
+        model = Notification

wbcore/contrib/notifications/factories/tokens.py

@@ -0,0 +1,11 @@
+import factory
+from wbcore.contrib.notifications.models.tokens import NotificationUserToken
+
+
+class NotificationUserTokenModelFactory(factory.django.DjangoModelFactory):
+    user = factory.SubFactory("wbcore.contrib.authentication.factories.UserFactory")
+    token = factory.Faker("pystr")
+    device_type = factory.Iterator(NotificationUserToken.NotificationDeviceType.choices, getter=lambda c: c[0])
+
+    class Meta:
+        model = NotificationUserToken

wbcore/contrib/notifications/migrations/0001_initial.py

@@ -0,0 +1,116 @@
+# Generated by Django 4.1 on 2023-02-23 12:05
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("contenttypes", "0002_remove_content_type_name"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="NotificationType",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("code", models.CharField(max_length=128, unique=True)),
+                ("title", models.CharField(default="", max_length=128)),
+                ("help_text", models.CharField(default="", max_length=512)),
+                ("stale", models.BooleanField(default=False)),
+                ("default_enable_web", models.BooleanField(default=False)),
+                ("default_enable_mobile", models.BooleanField(default=False)),
+                ("default_enable_email", models.BooleanField(default=False)),
+                (
+                    "contenttype",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="+",
+                        to="contenttypes.contenttype",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Notification Type",
+                "verbose_name_plural": "Notification Types",
+            },
+        ),
+        migrations.CreateModel(
+            name="NotificationUserToken",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("token", models.CharField(max_length=256)),
+                ("device_type", models.CharField(choices=[("WEB", "Web"), ("MOBILE", "Mobile")], max_length=16)),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="notifications_tokens",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="NotificationTypeSetting",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("enable_web", models.BooleanField(default=False)),
+                ("enable_mobile", models.BooleanField(default=False)),
+                ("enable_email", models.BooleanField(default=False)),
+                (
+                    "notification_type",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="user_settings",
+                        to="notifications.notificationtype",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="wbnotification_user_settings",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="Notification",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("title", models.CharField(max_length=255)),
+                ("body", models.TextField(default="")),
+                ("endpoint", models.CharField(blank=True, max_length=255, null=True)),
+                ("sent", models.DateTimeField(blank=True, null=True)),
+                ("read", models.DateTimeField(blank=True, null=True)),
+                (
+                    "notification_type",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="notifications",
+                        to="notifications.notificationtype",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="notifications_notifications",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Notification",
+                "verbose_name_plural": "Notifications",
+            },
+        ),
+    ]

wbcore/contrib/notifications/migrations/0002_notificationusertoken_unique_user_token_device.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.1 on 2023-03-30 09:21
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("notifications", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AddConstraint(
+            model_name="notificationusertoken",
+            constraint=models.UniqueConstraint(
+                fields=("user", "token", "device_type"), name="unique_user_token_device"
+            ),
+        ),
+    ]

wbcore/contrib/notifications/migrations/0003_notificationusertoken_updated.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.1.9 on 2023-05-24 08:39
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("notifications", "0002_notificationusertoken_unique_user_token_device"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="notificationusertoken",
+            name="updated",
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]

wbcore/contrib/notifications/migrations/0004_alter_notification_body.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.1.9 on 2023-05-30 07:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("notifications", "0003_notificationusertoken_updated"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="notification",
+            name="body",
+            field=models.TextField(blank=True, null=True),
+        ),
+    ]

wbcore/contrib/notifications/migrations/0005_alter_notification_endpoint.py

@@ -0,0 +1,17 @@
+# Generated by Django 5.0.3 on 2024-04-24 11:28
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("notifications", "0004_alter_notification_body"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="notification",
+            name="endpoint",
+            field=models.CharField(blank=True, max_length=2048, null=True),
+        ),
+    ]

wbcore/contrib/notifications/migrations/0006_notification_created.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.0.9 on 2024-12-05 13:27
+
+import django.utils.timezone
+from django.db import migrations, models
+
+
+def set_created(apps, schema_editor):
+    Notification = apps.get_model("notifications", "Notification")
+    Notification.objects.filter(sent__isnull=False).update(created=models.F("sent"))
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("notifications", "0005_alter_notification_endpoint"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="notification",
+            name="created",
+            field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now),
+            preserve_default=False,
+        ),
+        migrations.RunPython(set_created),
+    ]

wbcore/contrib/notifications/models/__init__.py

@@ -0,0 +1,3 @@
+from .notification_types import NotificationType, NotificationTypeSetting
+from .notifications import Notification
+from .tokens import NotificationUserToken

wbcore/contrib/notifications/models/notification_types.py

@@ -0,0 +1,112 @@
+from contextlib import suppress
+
+from django.contrib.auth import get_user_model
+from django.db import models
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from guardian.utils import get_anonymous_user
+from wbcore.models import WBModel
+
+
+class NotificationType(WBModel):
+    code = models.CharField(max_length=128, unique=True)
+    title = models.CharField(max_length=128, default="")
+    help_text = models.CharField(max_length=512, default="")
+
+    stale = models.BooleanField(default=False)
+    contenttype = models.ForeignKey(
+        to="contenttypes.ContentType", related_name="+", null=True, blank=True, on_delete=models.SET_NULL
+    )
+
+    default_enable_web = models.BooleanField(default=False)
+    default_enable_mobile = models.BooleanField(default=False)
+    default_enable_email = models.BooleanField(default=False)
+
+    def __str__(self) -> str:
+        return f"{self.title}"
+
+    class Meta:
+        verbose_name = "Notification Type"
+        verbose_name_plural = "Notification Types"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:notifications:notification_type"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:notifications:notification_type_representation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{title}}"
+
+
+class NotificationTypeSetting(WBModel):
+    notification_type = models.ForeignKey(
+        to="notifications.NotificationType", related_name="user_settings", on_delete=models.CASCADE
+    )
+    user = models.ForeignKey(
+        to=get_user_model(), related_name="wbnotification_user_settings", on_delete=models.CASCADE
+    )
+
+    enable_web = models.BooleanField(default=False)
+    enable_mobile = models.BooleanField(default=False)
+    enable_email = models.BooleanField(default=False)
+
+    def __str__(self) -> str:
+        return f"{self.user}: {self.notification_type} ({self.enable_web}/{self.enable_mobile}/{self.enable_email})"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcore:notifications:notification_type_setting"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcore:notifications:notification_type_setting_representation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{notification_type}}"
+
+
+@receiver(post_save, sender="notifications.NotificationType")
+def post_save_notification_type(instance, **kwargs):
+    anonymous_user = get_anonymous_user()
+    for user in get_user_model().objects.filter(~models.Q(pk=anonymous_user.pk)):
+        NotificationTypeSetting.objects.get_or_create(
+            notification_type=instance,
+            user=user,
+            defaults={
+                "enable_web": instance.default_enable_web,
+                "enable_mobile": instance.default_enable_mobile,
+                "enable_email": instance.default_enable_email,
+            },
+        )
+
+
+@receiver(post_save, sender=get_user_model())
+def post_save_user(instance, **kwargs):
+    with suppress(get_user_model().DoesNotExist):
+        anonymous_user = get_anonymous_user()
+        if instance.pk == anonymous_user.pk:
+            return
+
+    for notification_type in NotificationType.objects.all():
+        NotificationTypeSetting.objects.get_or_create(
+            notification_type=notification_type,
+            user=instance,
+            defaults={
+                "enable_web": notification_type.default_enable_web,
+                "enable_mobile": notification_type.default_enable_mobile,
+                "enable_email": notification_type.default_enable_email,
+            },
+        )

wbcore/contrib/notifications/models/notifications.py

@@ -0,0 +1,81 @@
+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
+
+
+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 = [
+            (
+                "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}}"