Merge pull request #75 from silverlogic/BA-notification-settings

baseapp-notifications: allow user to enable/disable notifications

Author: ficast

baseapp-notifications/README.md

@@ -71,15 +71,15 @@ CELERY_TASK_ROUTES = {
 }
 ```
 
-4 - Make sure that your main `User`'s `DjangoObjectType` implements interface `NotificationsNode`:
+4 - Make sure that your main `User`'s `DjangoObjectType` implements interface `NotificationsInterface`:
 
 ```python
 from baseapp_core.graphql import DjangoObjectType
-from baseapp_notifications.graphql.object_types import NotificationsNode
+from baseapp_notifications.graphql.object_types import NotificationsInterface
 
 class UserNode(DjangoObjectType):
     class Meta:
-        interfaces = (relay.Node, NotificationsNode)
+        interfaces = (relay.Node, NotificationsInterface)
 ```
 
 5 - Then you can expose notification's mutations and subscriptions:

baseapp-notifications/baseapp_notifications/admin.py

@@ -0,0 +1,11 @@
+import swapper
+from django.contrib import admin
+
+NotificationSetting = swapper.load_model("baseapp_notifications", "NotificationSetting")
+
+
+@admin.register(NotificationSetting)
+class NotificationSettingAdmin(admin.ModelAdmin):
+    list_display = ["user", "verb", "channel", "is_active", "created"]
+    list_filter = ["channel", "is_active"]
+    search_fields = ["user__username", "verb"]

baseapp-notifications/baseapp_notifications/base.py

@@ -1,4 +1,8 @@
 from baseapp_core.graphql.models import RelayModel
+from django.conf import settings
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from model_utils.models import TimeStampedModel
 from notifications.base.models import AbstractNotification as BaseAbstractNotification
 
 
@@ -27,3 +31,25 @@ def delete(self, *args, **kwargs):
         OnNotificationChange.send_delete_notification(
             recipient_id=self.recipient_id, notification_id=notification_relay_id
         )
+
+
+class AbstractNotificationSetting(TimeStampedModel, RelayModel):
+    class Meta:
+        abstract = True
+
+    class NotificationChannelTypes(models.IntegerChoices):
+        ALL = 0, _("All")
+        EMAIL = 1, _("Email")
+        PUSH = 2, _("Push")
+        IN_APP = 3, _("In-App")
+
+        @property
+        def description(self):
+            return self.label
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL, related_name="notifications_settings", on_delete=models.CASCADE
+    )
+    channel = models.IntegerField(choices=NotificationChannelTypes.choices)
+    verb = models.CharField(max_length=255)
+    is_active = models.BooleanField(default=True)

baseapp-notifications/baseapp_notifications/graphql/mutations.py

@@ -4,13 +4,19 @@
 from baseapp_core.graphql.utils import get_pk_from_relay_id
 from django.utils.translation import gettext_lazy as _
 
-from .object_types import NotificationNode, NotificationsNode
+from .object_types import (
+    NotificationChannelTypesEnum,
+    NotificationNode,
+    NotificationSettingNode,
+    NotificationsInterface,
+)
 
 Notification = swapper.load_model("notifications", "Notification")
+NotificationSetting = swapper.load_model("baseapp_notifications", "NotificationSetting")
 
 
 class NotificationsMarkAllAsRead(RelayMutation):
-    recipient = graphene.Field(NotificationsNode)
+    recipient = graphene.Field(NotificationsInterface)
 
     class Input:
         read = graphene.Boolean(required=True, description=_("Mark as read or unread"))
@@ -31,7 +37,7 @@ def mutate_and_get_payload(cls, root, info, read, **input):
 
 
 class NotificationsMarkAsRead(RelayMutation):
-    recipient = graphene.Field(NotificationsNode)
+    recipient = graphene.Field(NotificationsInterface)
     notifications = graphene.List(NotificationNode)
 
     class Input:
@@ -59,6 +65,63 @@ def mutate_and_get_payload(cls, root, info, notification_ids, read, **input):
         )
 
 
+class NotificationSettingToggle(RelayMutation):
+    notification_setting = graphene.Field(NotificationSettingNode)
+
+    class Input:
+        verb = graphene.String(required=True)
+        channel = graphene.Field(NotificationChannelTypesEnum, required=True)
+
+    @classmethod
+    @login_required
+    def mutate_and_get_payload(cls, root, info, verb, channel, **input):
+        # Determine if a setting other than 'ALL' exists for the given verb
+        is_channel_all = channel == NotificationSetting.NotificationChannelTypes.ALL
+
+        # Create or update the notification setting
+        notification_setting, created = NotificationSetting.objects.get_or_create(
+            user=info.context.user,
+            verb=verb,
+            channel=channel,
+            defaults={"is_active": False},
+        )
+
+        if not created:
+            notification_setting.is_active = not notification_setting.is_active
+            notification_setting.save(update_fields=["is_active"])
+
+        # Update other settings based on 'ALL' channel logic
+        if is_channel_all:
+            has_non_active_setting = (
+                NotificationSetting.objects.filter(
+                    user=info.context.user, verb=verb, is_active=False
+                )
+                .exclude(channel=NotificationSetting.NotificationChannelTypes.ALL)
+                .exists()
+            )
+            if has_non_active_setting:
+                # If a non-active setting exists, update 'ALL' setting to False
+                NotificationSetting.objects.filter(
+                    user=info.context.user,
+                    verb=verb,
+                    channel=NotificationSetting.NotificationChannelTypes.ALL,
+                ).update(is_active=False)
+            # Update all settings to match the 'ALL' setting
+            NotificationSetting.objects.filter(user=info.context.user, verb=verb).update(
+                is_active=notification_setting.is_active
+            )
+        else:
+            # If the current channel is not 'ALL', ensure 'ALL' settings are updated to match
+            NotificationSetting.objects.filter(
+                user=info.context.user,
+                verb=verb,
+                channel=NotificationSetting.NotificationChannelTypes.ALL,
+            ).update(is_active=notification_setting.is_active)
+
+        return NotificationSettingToggle(notification_setting=notification_setting)
+
+
 class NotificationsMutations(object):
     notifications_mark_as_read = NotificationsMarkAsRead.Field()
     notifications_mark_all_as_read = NotificationsMarkAllAsRead.Field()
+    notification_setting_toggle = NotificationSettingToggle.Field()

baseapp-notifications/baseapp_notifications/graphql/object_types.py

@@ -3,18 +3,27 @@
 import swapper
 from baseapp_core.graphql import DjangoObjectType
 from graphene import relay
+from graphene_django import DjangoConnectionField
 from graphene_django.filter import DjangoFilterConnectionField
 
+from ..utils import can_user_receive_notification
 from .filters import NotificationFilter
 
 Notification = swapper.load_model("notifications", "Notification")
+NotificationSetting = swapper.load_model("baseapp_notifications", "NotificationSetting")
+NotificationChannelTypesEnum = graphene.Enum.from_enum(NotificationSetting.NotificationChannelTypes)
 
 
-class NotificationsNode(relay.Node):
+class NotificationsInterface(relay.Node):
     notifications_unread_count = graphene.Int()
     notifications = DjangoFilterConnectionField(
         lambda: NotificationNode, filterset_class=NotificationFilter
     )
+    notification_settings = DjangoConnectionField(lambda: NotificationSettingNode)
+    is_notification_setting_active = graphene.Boolean(
+        verb=graphene.String(required=True),
+        channel=NotificationChannelTypesEnum(required=True),
+    )
 
     def resolve_notifications_unread_count(self, info):
         if self.is_authenticated:
@@ -28,6 +37,16 @@ def resolve_notifications(self, info, **kwargs):
             )
         return Notification.objects.none()
 
+    def resolve_notification_settings(self, info, **kwargs):
+        if info.context.user.is_authenticated and info.context.user == self:
+            return NotificationSetting.objects.filter(user=info.context.user)
+        return NotificationSetting.objects.none()
+
+    def resolve_is_notification_setting_active(self, info, verb, channel, **kwargs):
+        if info.context.user.is_authenticated and info.context.user == self:
+            return can_user_receive_notification(info.context.user.id, verb, channel)
+        return False
+
 
 class NotificationNode(gql_optimizer.OptimizedDjangoObjectType, DjangoObjectType):
     actor = graphene.Field(relay.Node)
@@ -56,3 +75,30 @@ def get_queryset(cls, queryset, info):
             return queryset.none()
 
         return super().get_queryset(queryset.filter(recipient=info.context.user), info)
+
+
+class NotificationSettingNode(gql_optimizer.OptimizedDjangoObjectType, DjangoObjectType):
+    channel = graphene.Field(NotificationChannelTypesEnum)
+
+    class Meta:
+        model = NotificationSetting
+        fields = "__all__"
+        interfaces = (relay.Node,)
+
+    @classmethod
+    def get_queryset(cls, queryset, info):
+        if not info.context.user.is_authenticated:
+            return queryset.none()
+
+        return super().get_queryset(queryset.filter(user=info.context.user), info)
+
+    @classmethod
+    def get_node(cls, info, id):
+        if not info.context.user.is_authenticated:
+            return None
+
+        try:
+            queryset = cls.get_queryset(cls._meta.model.objects, info)
+            return queryset.get(id=id, user=info.context.user)
+        except cls._meta.model.DoesNotExist:
+            return None

baseapp-notifications/baseapp_notifications/migrations/0002_notificationsetting.py

@@ -0,0 +1,60 @@
+# Generated by Django 4.2.10 on 2024-02-08 13:53
+
+import django.db.models.deletion
+import django.utils.timezone
+import model_utils.fields
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("baseapp_notifications", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="NotificationSetting",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                (
+                    "created",
+                    model_utils.fields.AutoCreatedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name="created"
+                    ),
+                ),
+                (
+                    "modified",
+                    model_utils.fields.AutoLastModifiedField(
+                        default=django.utils.timezone.now, editable=False, verbose_name="modified"
+                    ),
+                ),
+                (
+                    "channel",
+                    models.IntegerField(
+                        choices=[(0, "All"), (1, "Email"), (2, "Push"), (3, "In-App")]
+                    ),
+                ),
+                ("verb", models.CharField(max_length=255)),
+                ("is_active", models.BooleanField(default=True)),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="notifications_settings",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "swappable": "BASEAPP_NOTIFICATIONS_NOTIFICATIONSETTING_MODEL",
+            },
+        ),
+    ]

baseapp-notifications/baseapp_notifications/models.py

@@ -1,6 +1,13 @@
-from .base import AbstractNotification
+import swapper
+
+from .base import AbstractNotification, AbstractNotificationSetting
 
 
 class Notification(AbstractNotification):
     class Meta(AbstractNotification.Meta):
         abstract = False
+
+
+class NotificationSetting(AbstractNotificationSetting):
+    class Meta:
+        swappable = swapper.swappable_setting("baseapp_notifications", "NotificationSetting")

baseapp-notifications/baseapp_notifications/tests/factories.py

@@ -18,3 +18,10 @@ class NotificationFactory(AbstractNotificationFactory):
 
     class Meta:
         model = Notification
+
+
+class NotificationSettingFactory(factory.django.DjangoModelFactory):
+    user = factory.SubFactory(UserFactory)
+
+    class Meta:
+        model = swapper.load_model("baseapp_notifications", "NotificationSetting")