feat: Added new NotificationType.forbidden_channels property to disable certain channels for certain notification types

Author: kevinrenskers

example/notifications/templates/settings.html

@@ -41,9 +41,9 @@ <h1 class="text-xl">Notification settings</h1>
                            name="{{ type_data.notification_type.key }}__{{ channel_key }}"
                            class="checkbox checkbox-primary"
                            {% if channel_data.enabled %}checked{% endif %}
-                           {% if channel_data.required %}disabled{% endif %}
-                           {% if channel_key == 'email' %}@change="emailEnabled = $event.target.checked"{% endif %}
-                           {% if channel_data.required %}title="Required"{% endif %} />
+                           {% if channel_data.forbidden %}disabled title="Forbidden"{% endif %}
+                           {% if channel_data.required %}disabled title="Required"{% endif %}
+                           {% if channel_key == 'email' %}@change="emailEnabled = $event.target.checked"{% endif %} />
                   {% endwith %}
                 </td>
               {% endfor %}

example/notifications/types.py

@@ -1,3 +1,4 @@
+from generic_notifications.channels import EmailChannel
 from generic_notifications.types import NotificationType, register
 
 
@@ -6,3 +7,11 @@ class CommentNotificationType(NotificationType):
     key = "comment_notification"
     name = "Comments"
     description = "You received a comment"
+
+
+@register
+class WebsiteOnlyNotificationType(NotificationType):
+    key = "website_only_notification"
+    name = "Website only"
+    description = "Just a test notification"
+    forbidden_channels = [EmailChannel]

example/uv.lock

@@ -45,11 +45,13 @@ def get_notification_preferences(user: "AbstractUser") -> List[Dict[str, Any]]:
             channel_key = channel.key
             is_disabled = (type_key, channel_key) in disabled_channels
             is_required = channel_key in [ch.key for ch in notification_type.required_channels]
+            is_forbidden = channel_key in [ch.key for ch in notification_type.forbidden_channels]
 
             type_data["channels"][channel_key] = {
                 "channel": channel,
-                "enabled": is_required or not is_disabled,  # Required channels are always enabled
+                "enabled": not is_forbidden and (is_required or not is_disabled),
                 "required": is_required,
+                "forbidden": is_forbidden,
             }
 
         settings_data.append(type_data)
@@ -85,9 +87,11 @@ def save_notification_preferences(user: "AbstractUser", form_data: Dict[str, Any
             channel_key = channel.key
             form_key = f"{type_key}__{channel_key}"
 
-            # Check if this channel is required (cannot be disabled)
+            # Check if this channel is required or forbidden (cannot be changed)
             if channel_key in [ch.key for ch in notification_type.required_channels]:
                 continue
+            if channel_key in [ch.key for ch in notification_type.forbidden_channels]:
+                continue
 
             # If checkbox not checked, create disabled entry
             if form_key not in form_data:

generic_notifications/preferences.py

@@ -19,6 +19,7 @@ class NotificationType(ABC):
     description: str
     default_frequency: Type[BaseFrequency] = DailyFrequency
     required_channels: list[Type[BaseChannel]] = []
+    forbidden_channels: list[Type[BaseChannel]] = []
 
     def __str__(self) -> str:
         return self.name
@@ -117,10 +118,13 @@ def get_enabled_channels(cls, user: Any) -> list[Type[BaseChannel]]:
             )
         )
 
-        # Filter out disabled channels
+        # Get all forbidden channel keys
+        forbidden_channel_keys = {channel_cls.key for channel_cls in cls.forbidden_channels}
+
+        # Filter out disabled and forbidden channels
         enabled_channels = []
         for channel_cls in registry.get_all_channels():
-            if channel_cls.key not in disabled_channel_keys:
+            if channel_cls.key not in disabled_channel_keys and channel_cls.key not in forbidden_channel_keys:
                 enabled_channels.append(channel_cls)
 
         return enabled_channels

generic_notifications/types.py

@@ -1,6 +1,6 @@
 [project]
 name = "django-generic-notifications"
-version = "2.0.1"
+version = "2.1.0"
 description = "A flexible, multi-channel notification system for Django applications with built-in support for email digests, user preferences, and extensible delivery channels."
 authors = [
     {name = "Kevin Renskers", email = "[email protected]"},

pyproject.toml

@@ -213,3 +213,56 @@ def test_reset_to_default(self):
         # Getting frequency should now return the default
         frequency_cls = TestNotificationType.get_frequency(self.user)
         self.assertEqual(frequency_cls, TestNotificationType.default_frequency)
+
+
+class ForbiddenChannelsNotificationType(NotificationType):
+    key = "forbidden_test_type"
+    name = "Forbidden Test Type"
+    description = "A test notification type with forbidden channels"
+    forbidden_channels = [WebsiteChannel]
+
+
+class TestForbiddenChannels(TestCase):
+    user: Any
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.user = User.objects.create_user(
+            username="forbidden_test", email="[email protected]", password="testpass"
+        )
+        registry.register_type(ForbiddenChannelsNotificationType)
+
+    def test_forbidden_channels_not_in_enabled_channels(self):
+        """Test that forbidden channels are not included in get_enabled_channels"""
+        enabled_channels = ForbiddenChannelsNotificationType.get_enabled_channels(self.user)
+        enabled_channel_keys = [ch.key for ch in enabled_channels]
+
+        # Website channel should not be in enabled channels
+        self.assertNotIn(WebsiteChannel.key, enabled_channel_keys)
+        # Email channel should still be enabled
+        self.assertIn(EmailChannel.key, enabled_channel_keys)
+
+    def test_forbidden_channels_filtered_even_when_explicitly_enabled(self):
+        """Test that forbidden channels are filtered out even if user tries to enable them"""
+        # Try to enable the forbidden channel (this should have no effect)
+        ForbiddenChannelsNotificationType.enable_channel(self.user, WebsiteChannel)
+
+        enabled_channels = ForbiddenChannelsNotificationType.get_enabled_channels(self.user)
+        enabled_channel_keys = [ch.key for ch in enabled_channels]
+
+        # Website channel should still not be in enabled channels
+        self.assertNotIn(WebsiteChannel.key, enabled_channel_keys)
+
+    def test_forbidden_channels_filtered_when_not_disabled(self):
+        """Test that forbidden channels are filtered out regardless of disabled state"""
+        # Ensure no disabled entry exists for the forbidden channel
+        DisabledNotificationTypeChannel.objects.filter(
+            user=self.user, notification_type=ForbiddenChannelsNotificationType.key, channel=WebsiteChannel.key
+        ).delete()
+
+        enabled_channels = ForbiddenChannelsNotificationType.get_enabled_channels(self.user)
+        enabled_channel_keys = [ch.key for ch in enabled_channels]
+
+        # Website channel should still not be in enabled channels
+        self.assertNotIn(WebsiteChannel.key, enabled_channel_keys)

tests/test_types.py

@@ -4,7 +4,7 @@
 from django.test import TestCase
 
 from generic_notifications import send_notification
-from generic_notifications.channels import WebsiteChannel
+from generic_notifications.channels import EmailChannel, WebsiteChannel
 from generic_notifications.models import Notification
 from generic_notifications.registry import registry
 from generic_notifications.types import NotificationType
@@ -122,6 +122,47 @@ def test_send_notification_multiple_channels(self):
         self.assertIn("email", channel_keys)
         self.assertEqual(len(channel_keys), 2)
 
+    def test_send_notification_with_disabled_channel(self):
+        # Disable website channel for this user
+        self.notification_type.disable_channel(self.user, WebsiteChannel)
+
+        notification = send_notification(recipient=self.user, notification_type=self.notification_type)
+
+        # Notification should only have email channel
+        self.assertIsNotNone(notification)
+        channel_keys = notification.get_channels()
+        self.assertNotIn("website", channel_keys)
+        self.assertIn("email", channel_keys)
+        self.assertEqual(len(channel_keys), 1)
+
+    def test_send_notification_with_all_channels_disabled(self):
+        # Disable both channels for this user
+        self.notification_type.disable_channel(self.user, WebsiteChannel)
+        self.notification_type.disable_channel(self.user, EmailChannel)
+
+        notification = send_notification(recipient=self.user, notification_type=self.notification_type)
+
+        # Should return None when no channels are enabled
+        self.assertIsNone(notification)
+
+    def test_send_notification_with_forbidden_channels(self):
+        # Create a notification type with forbidden channels
+        class ForbiddenTestType(NotificationType):
+            key = "forbidden_test"
+            name = "Forbidden Test"
+            forbidden_channels = [WebsiteChannel]
+
+        registry.register_type(ForbiddenTestType)
+
+        notification = send_notification(recipient=self.user, notification_type=ForbiddenTestType)
+
+        # Should only have email channel (website is forbidden)
+        self.assertIsNotNone(notification)
+        channel_keys = notification.get_channels()
+        self.assertNotIn("website", channel_keys)
+        self.assertIn("email", channel_keys)
+        self.assertEqual(len(channel_keys), 1)
+
 
 class MarkNotificationsAsReadTest(TestCase):
     def setUp(self):