wbcore 1.61.5__tar.gz → 1.61.6__tar.gz

{wbcore-1.61.5 → wbcore-1.61.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbcore
-Version: 1.61.5
+Version: 1.61.6
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 Requires-Dist: celery[redis]==5.*
 Requires-Dist: croniter==2.*

{wbcore-1.61.5 → wbcore-1.61.6}/wbcore/contrib/authentication/admin.py

@@ -78,7 +78,13 @@ class UserAdmin(admin.ModelAdmin):
         (_("Synchronization"), {"fields": ("metadata",)}),
         (
             _("Permissions"),
-            {"fields": ("is_active", "is_register", "is_staff", "is_superuser", "groups", "user_permissions")},
+            {
+                "fields": (
+                    ("is_active", "is_register", "is_staff", "is_superuser", "is_internal"),
+                    ("groups",),
+                    ("user_permissions",),
+                )
+            },
         ),
     )
     raw_id_fields = ("profile",)

{wbcore-1.61.5 → wbcore-1.61.6}/wbcore/contrib/notifications/admin.py

@@ -2,7 +2,7 @@ from datetime import date, timedelta
 
 from django.contrib import admin
 
-from wbcore.contrib.notifications.tasks import send_notification_task
+from wbcore.contrib.notifications.models.notifications import send_notification_as_task
 
 from .models import (
     Notification,
@@ -16,19 +16,12 @@ from .models import (
 class NotificationModelAdmin(admin.ModelAdmin):
     search_fields = ["title", "body"]
 
-    list_display = [
-        "title",
-        "user",
-        "notification_type",
-        "endpoint",
-        "sent",
-        "read",
-    ]
+    list_display = ["title", "user", "notification_type", "endpoint", "sent", "read", "created"]
 
     @admin.action(description="Send Notification")
     def send_notification(self, request, queryset):
         for notification in queryset:
-            send_notification_task.delay(notification.id)
+            send_notification_as_task.delay(notification.id)
 
     actions = [send_notification]
 

{wbcore-1.61.5 → wbcore-1.61.6}/wbcore/contrib/notifications/backends/firebase/backends.py

@@ -11,9 +11,6 @@ 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):
@@ -34,11 +31,8 @@ class NotificationBackend(AbstractNotificationBackend):
     @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)
+        notification_user_setting = notification.notification_type.get_setting_for_user(notification.user)
+        tokens = NotificationUserToken.objects.filter_for_user_settings(notification_user_setting)
         endpoint_data = {}  # Firebase can't accept non-string value
         if full_endpoint := notification.get_full_endpoint():
             endpoint_data["endpoint"] = full_endpoint

{wbcore-1.61.5 → wbcore-1.61.6}/wbcore/contrib/notifications/dispatch.py

@@ -4,7 +4,6 @@ from celery import shared_task
 from django.conf import settings
 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
@@ -13,15 +12,24 @@ from wbcore.contrib.authentication.models.users import User
 from wbcore.shares.signals import handle_widget_sharing
 
 from ...workers import Queue
-from .models import Notification, NotificationType, NotificationTypeSetting
-from .tasks import send_notification_task
+from .models import NotificationType
+from .models.notifications import Notification, send_notification_as_task
 
 
+def get_user(u: User | int) -> User:
+    if isinstance(u, User):
+        return u
+    elif isinstance(u, int):
+        return User.objects.get(id=u)
+    raise ValueError("Invalid user type")
+
+
+@shared_task(queue=Queue.HIGH_PRIORITY.value)
 def send_notification(
     code: str,
     title: str,
     body: str,
-    user: User | Iterable[User],
+    user: User | Iterable[User | int] | int,
     reverse_name: str | None = None,
     reverse_args=None,
     reverse_kwargs=None,
@@ -39,15 +47,16 @@ def send_notification(
         reverse_kwargs: The keyword arguments passed to the `reverse` function
         endpoint: The endpoint of resource. If provided, reverse_name + args + kwargs are disregarded
     """
-    users = user
-    if isinstance(users, User):
-        users = [users]
+    users = []
+    if isinstance(user, list):
+        for u in user:
+            users.append(get_user(u))
+    else:
+        users.append(get_user(user))
+
     for user in users:
         notification_type = NotificationType.objects.get(code=code)
-        if (
-            user.is_active
-            and NotificationTypeSetting.objects.filter(notification_type=notification_type, user=user).exists()
-        ):
+        if user.is_active:
             if not endpoint:
                 endpoint = reverse(reverse_name, reverse_args, reverse_kwargs) if reverse_name else None
             notification = Notification.objects.create(
@@ -56,21 +65,12 @@ def send_notification(
                 user=user,
                 notification_type=notification_type,
                 endpoint=endpoint,
-                sent=timezone.now(),
             )
             transaction.on_commit(
-                lambda notification_pk=notification.pk: send_notification_task.delay(notification_pk)
+                lambda notification_pk=notification.pk: send_notification_as_task.delay(notification_pk)
             )
 
 
-@shared_task(queue=Queue.HIGH_PRIORITY.value)
-def send_notification_as_task(code, title, body, user_id, **kwargs):
-    if not isinstance(user_id, list):
-        user_id = [user_id]
-    user = User.objects.filter(id__in=user_id)
-    send_notification(code, title, body, user, **kwargs)
-
-
 @receiver(handle_widget_sharing)
 def share_notification(
     request, widget_relative_endpoint, share=False, share_message=None, share_recipients=None, **kwargs

{wbcore-1.61.5 → wbcore-1.61.6}/wbcore/contrib/notifications/factories/notifications.py

@@ -6,7 +6,7 @@ from wbcore.contrib.notifications.factories.notification_types import (
 from wbcore.contrib.notifications.models import Notification
 
 
-class NotificationModelFactory(factory.django.DjangoModelFactory):
+class NotificationFactory(factory.django.DjangoModelFactory):
     title = factory.Faker("pystr")
     body = factory.Faker("pystr")
     notification_type = factory.SubFactory(NotificationTypeModelFactory)

wbcore-1.61.6/wbcore/contrib/notifications/migrations/0010_notification_checksum_notification_checksum_unique.py

@@ -0,0 +1,50 @@
+# Generated by Django 5.2.9 on 2026-02-02 11:27
+import hashlib
+
+from django.conf import settings
+from django.db import migrations, models
+from tqdm import tqdm
+
+from wbcore.contrib.notifications.utils import get_checksum
+
+
+def migrate_checksum(apps, schema_editor):
+    Notification = apps.get_model('notifications', 'Notification')
+    qs = Notification.objects.all()
+    objs = []
+    for notification in tqdm(qs, total=qs.count()):
+        notification.checksum = get_checksum(notification.title, notification.body, notification.endpoint)
+        objs.append(notification)
+    Notification.objects.bulk_update(objs, ["checksum"], batch_size=1000)
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('notifications', '0009_alter_notificationtypesetting_options_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='notification',
+            name='checksum',
+            field=models.CharField(null=True, blank=True, max_length=64),
+            preserve_default=False,
+        ),
+        migrations.RunPython(migrate_checksum),
+        migrations.AlterField(
+            model_name='notification',
+            name='body',
+            field=models.TextField(default=''),
+        ),
+        migrations.AlterField(
+            model_name='notification',
+            name='checksum',
+            field=models.CharField(default=None, max_length=64),
+            preserve_default=False,
+        ),
+        migrations.AddIndex(
+            model_name='notification',
+            index=models.Index(fields=['user', 'notification_type', 'checksum'], name='notificatio_user_id_b90c58_idx'),
+        ),
+    ]

{wbcore-1.61.5 → wbcore-1.61.6}/wbcore/contrib/notifications/models/notification_types.py

@@ -10,54 +10,6 @@ from wbcore.contrib.authentication.models.users import 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
-    )
-    resource_button_label = models.CharField(max_length=128)
-
-    default_enable_web = models.BooleanField(default=False)
-    default_enable_mobile = models.BooleanField(default=False)
-    default_enable_email = models.BooleanField(default=False)
-    is_lock = models.BooleanField(default=False)
-
-    def __str__(self) -> str:
-        return f"{self.title}"
-
-    def save(self, *args, **kwargs):
-        if not self.resource_button_label:
-            if self.contenttype:
-                self.resource_button_label = f"Open {self.contenttype.name}"
-            else:
-                self.resource_button_label = "Open Resource"
-        super().save(*args, **kwargs)
-
-    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
@@ -106,31 +58,81 @@ class NotificationTypeSetting(WBModel):
         return "{{notification_type}}"
 
 
+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
+    )
+    resource_button_label = models.CharField(max_length=128)
+
+    default_enable_web = models.BooleanField(default=False)
+    default_enable_mobile = models.BooleanField(default=False)
+    default_enable_email = models.BooleanField(default=False)
+    is_lock = models.BooleanField(default=False)
+
+    def __str__(self) -> str:
+        return f"{self.title}"
+
+    def save(self, *args, **kwargs):
+        if not self.resource_button_label:
+            if self.contenttype:
+                self.resource_button_label = f"Open {self.contenttype.name}"
+            else:
+                self.resource_button_label = "Open Resource"
+        super().save(*args, **kwargs)
+
+    class Meta:
+        verbose_name = "Notification Type"
+        verbose_name_plural = "Notification Types"
+
+    def get_setting_for_user(self, user: User, bulk: bool = False) -> NotificationTypeSetting:
+        try:
+            setting = NotificationTypeSetting.objects.get(user=user, notification_type=self)
+            setting.enable_web = setting.enable_web if not self.is_lock else self.default_enable_web
+            setting.enable_mobile = setting.enable_mobile if not self.is_lock else self.default_enable_mobile
+            setting.enable_email = setting.enable_email if not self.is_lock else self.default_enable_email
+            return setting
+        except NotificationTypeSetting.DoesNotExist:
+            setting = NotificationTypeSetting(
+                user=user,
+                notification_type=self,
+                enable_web=self.default_enable_web,
+                enable_mobile=self.default_enable_mobile,
+                enable_email=self.default_enable_email,
+            )
+            if not bulk:
+                setting.save()
+            return setting
+
+    @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}}"
+
+
 @receiver(post_save, sender="notifications.NotificationType")
 def post_save_notification_type(instance, **kwargs):
     anonymous_user = get_anonymous_user()
 
     objs = []
     for user in User.objects.filter(~models.Q(pk=anonymous_user.pk)):
-        try:
-            existing_setting = NotificationTypeSetting.objects.get(user=user, notification_type=instance)
-            enable_web = existing_setting.enable_web if not instance.is_lock else instance.default_enable_web
-            enable_mobile = existing_setting.enable_mobile if not instance.is_lock else instance.default_enable_mobile
-            enable_email = existing_setting.enable_email if not instance.is_lock else instance.default_enable_email
-        except NotificationTypeSetting.DoesNotExist:
-            enable_web = instance.default_enable_web
-            enable_mobile = instance.default_enable_mobile
-            enable_email = instance.default_enable_email
-
-        objs.append(
-            NotificationTypeSetting(
-                notification_type=instance,
-                user=user,
-                enable_web=enable_web,
-                enable_mobile=enable_mobile,
-                enable_email=enable_email,
-            )
-        )
+        setting = instance.get_setting_for_user(user, bulk=True)
+        objs.append(setting)
     if objs:
         NotificationTypeSetting.objects.bulk_create(
             objs,
@@ -150,14 +152,7 @@ def post_save_user(sender, instance, created, raw, **kwargs):
 
         objs = []
         for notification_type in NotificationType.objects.all():
-            objs.append(
-                NotificationTypeSetting(
-                    notification_type=notification_type,
-                    user=instance,
-                    enable_web=notification_type.default_enable_web,
-                    enable_mobile=notification_type.default_enable_mobile,
-                    enable_email=notification_type.default_enable_email,
-                )
-            )
+            setting = notification_type.get_setting_for_user(instance, bulk=True)
+            objs.append(setting)
         if objs:
             NotificationTypeSetting.objects.bulk_create(objs, unique_fields=["notification_type", "user"])

wbcore-1.61.6/wbcore/contrib/notifications/models/notifications.py

@@ -0,0 +1,165 @@
+import urllib
+from contextlib import suppress
+from datetime import timedelta
+
+from celery import shared_task
+from django.conf import settings
+from django.core.mail import EmailMultiAlternatives
+from django.core.validators import URLValidator, ValidationError
+from django.db import models
+from django.template.loader import get_template
+from django.urls import Resolver404, resolve
+from django.utils import timezone
+from django.utils.functional import cached_property
+from django.utils.html import strip_tags
+from django.utils.module_loading import import_string
+
+from wbcore.contrib.authentication.models.users import User
+from wbcore.contrib.notifications.utils import base_domain, create_notification_type, get_checksum
+from wbcore.workers import Queue
+
+
+class Notification(models.Model):
+    title = models.CharField(max_length=255)
+    body = models.TextField(default="")
+    endpoint = models.CharField(max_length=2048, null=True, blank=True)
+
+    user = models.ForeignKey(to=User, related_name="notifications_notifications", on_delete=models.CASCADE)
+    notification_type = models.ForeignKey(
+        to="notifications.NotificationType", related_name="notifications", on_delete=models.CASCADE
+    )
+
+    created = models.DateTimeField(auto_now_add=True)
+    sent = models.DateTimeField(null=True, blank=True)
+    read = models.DateTimeField(null=True, blank=True)
+    checksum = models.CharField(max_length=64)
+
+    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,
+            ),
+        ]
+        indexes = [
+            models.Index(fields=["user", "notification_type", "checksum"]),
+        ]
+        # constraints = [
+        #     models.UniqueConstraint(fields=["user", "checksum"], name="checksum_unique"),
+        # ]
+
+    @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 _send_as_mail(self):
+        """Sends out a notification to the user specified inside the notification"""
+
+        context = {
+            "title": self.title,
+            "message": self.body or "",
+            "notification_share_url": self.get_full_endpoint(as_shareable_internal_link=True),
+            "notification_endpoint": self.get_full_endpoint(),
+        }
+        rendered_template = get_template("notifications/notification_template.html").render(context)
+        msg = EmailMultiAlternatives(
+            subject=self.title,
+            body=strip_tags(rendered_template),
+            from_email=getattr(settings, "WBCORE_NOTIFICATION_EMAIL_FROM", "no_reply@stainly.com"),
+            to=[self.user.email],  # type: ignore
+        )
+        msg.attach_alternative(rendered_template, "text/html")
+        msg.send()
+
+    def save(self, *args, **kwargs):
+        if not self.checksum:
+            self.checksum = self.get_checksum()
+        super().save(*args, **kwargs)
+
+    def has_duplicated(self, interval: int = 60 * 4) -> bool:
+        return (
+            Notification.objects.exclude(id=self.id)
+            .filter(
+                user=self.user,
+                notification_type=self.notification_type,
+                checksum=self.checksum,
+                sent__isnull=False,
+                created__gt=self.created - timedelta(minutes=interval),
+                created__lt=self.created + timedelta(minutes=interval),
+            )
+            .exists()
+        )
+
+    def send(self):
+        notification_user_setting = self.notification_type.get_setting_for_user(self.user)
+
+        # we do not sent notification through email if we detect similar already sent notification
+        if notification_user_setting.enable_email and not self.has_duplicated():
+            self._send_as_mail()
+        if notification_user_setting.enable_web or notification_user_setting.enable_mobile:
+            backend = import_string(settings.NOTIFICATION_BACKEND)
+            backend.send_notification(self)
+
+        # mark this notification as sent
+        self.sent = timezone.now()
+        self.save()
+
+    def get_checksum(self) -> str:
+        return get_checksum(self.title, self.body, self.endpoint)
+
+    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}}"
+
+
+@shared_task(queue=Queue.HIGH_PRIORITY.value)
+def send_notification_as_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.send()

{wbcore-1.61.5 → wbcore-1.61.6}/wbcore/contrib/notifications/tests/conftest.py

@@ -8,7 +8,7 @@ from wbcore.contrib.notifications.factories.notification_types import (
     NotificationTypeSettingModelFactory,
 )
 from wbcore.contrib.notifications.factories.notifications import (
-    NotificationModelFactory,
+    NotificationFactory,
 )
 from wbcore.contrib.notifications.factories.tokens import (
     NotificationUserTokenModelFactory,
@@ -19,7 +19,7 @@ register(UserFactory)
 register(PersonFactory)
 register(NotificationTypeModelFactory, name="notification_type")
 register(NotificationTypeSettingModelFactory, name="notification_type_setting")
-register(NotificationModelFactory, name="notification")
+register(NotificationFactory)
 register(NotificationUserTokenModelFactory, name="notification_user_token")