[ENG-8064] Add New Notifications Data Model

admin/notifications/views.py

@@ -1,17 +1,17 @@
-from osf.models.notifications import NotificationSubscription
+from osf.models.notifications import NotificationSubscriptionLegacy
 from django.db.models import Count
 
 def delete_selected_notifications(selected_ids):
-    NotificationSubscription.objects.filter(id__in=selected_ids).delete()
+    NotificationSubscriptionLegacy.objects.filter(id__in=selected_ids).delete()
 
 def detect_duplicate_notifications(node_id=None):
-    query = NotificationSubscription.objects.values('_id').annotate(count=Count('_id')).filter(count__gt=1)
+    query = NotificationSubscriptionLegacy.objects.values('_id').annotate(count=Count('_id')).filter(count__gt=1)
     if node_id:
         query = query.filter(node_id=node_id)
 
     detailed_duplicates = []
     for dup in query:
-        notifications = NotificationSubscription.objects.filter(
+        notifications = NotificationSubscriptionLegacy.objects.filter(
             _id=dup['_id']
         ).order_by('created')
 

admin_tests/notifications/test_views.py

@@ -1,10 +1,11 @@
 import pytest
 from django.test import RequestFactory
-from osf.models import OSFUser, NotificationSubscription, Node
+from osf.models import OSFUser, Node
 from admin.notifications.views import (
     delete_selected_notifications,
     detect_duplicate_notifications,
 )
+from osf.models.notifications import NotificationSubscriptionLegacy
 from tests.base import AdminTestCase
 
 pytestmark = pytest.mark.django_db
@@ -18,19 +19,19 @@ def setUp(self):
         self.request_factory = RequestFactory()
 
     def test_delete_selected_notifications(self):
-        notification1 = NotificationSubscription.objects.create(user=self.user, node=self.node, event_name='event1')
-        notification2 = NotificationSubscription.objects.create(user=self.user, node=self.node, event_name='event2')
-        notification3 = NotificationSubscription.objects.create(user=self.user, node=self.node, event_name='event3')
+        notification1 = NotificationSubscriptionLegacy.objects.create(user=self.user, node=self.node, event_name='event1')
+        notification2 = NotificationSubscriptionLegacy.objects.create(user=self.user, node=self.node, event_name='event2')
+        notification3 = NotificationSubscriptionLegacy.objects.create(user=self.user, node=self.node, event_name='event3')
 
         delete_selected_notifications([notification1.id, notification2.id])
 
-        assert not NotificationSubscription.objects.filter(id__in=[notification1.id, notification2.id]).exists()
-        assert NotificationSubscription.objects.filter(id=notification3.id).exists()
+        assert not NotificationSubscriptionLegacy.objects.filter(id__in=[notification1.id, notification2.id]).exists()
+        assert NotificationSubscriptionLegacy.objects.filter(id=notification3.id).exists()
 
     def test_detect_duplicate_notifications(self):
-        NotificationSubscription.objects.create(user=self.user, node=self.node, event_name='event1')
-        NotificationSubscription.objects.create(user=self.user, node=self.node, event_name='event1')
-        NotificationSubscription.objects.create(user=self.user, node=self.node, event_name='event2')
+        NotificationSubscriptionLegacy.objects.create(user=self.user, node=self.node, event_name='event1')
+        NotificationSubscriptionLegacy.objects.create(user=self.user, node=self.node, event_name='event1')
+        NotificationSubscriptionLegacy.objects.create(user=self.user, node=self.node, event_name='event2')
 
         duplicates = detect_duplicate_notifications()
 

api/providers/workflows.py

@@ -24,4 +24,7 @@ class Workflows(ChoiceEnum):
         DefaultStates.PENDING.value,
         DefaultStates.ACCEPTED.value,
     ),
+    Workflows.HYBRID_MODERATION.value: (
+        DefaultStates.ACCEPTED.value,
+    ),
 }

api/subscriptions/fields.py

@@ -0,0 +1,12 @@
+from rest_framework import serializers as ser
+from osf.models import NotificationSubscription
+
+class FrequencyField(ser.ChoiceField):
+    def __init__(self, **kwargs):
+        super().__init__(choices=['none', 'instantly', 'daily', 'weekly', 'monthly'], **kwargs)
+
+    def to_representation(self, obj: NotificationSubscription):
+        return obj.message_frequency
+
+    def to_internal_value(self, freq):
+        return super().to_internal_value(freq)

api/subscriptions/permissions.py

@@ -1,13 +1,10 @@
 from rest_framework import permissions
 
-from osf.models.notifications import NotificationSubscription
+from osf.models.notification import NotificationSubscription
 
 
 class IsSubscriptionOwner(permissions.BasePermission):
 
     def has_object_permission(self, request, view, obj):
         assert isinstance(obj, NotificationSubscription), f'obj must be a NotificationSubscription; got {obj}'
-        user_id = request.user.id
-        return obj.none.filter(id=user_id).exists() \
-               or obj.email_transactional.filter(id=user_id).exists() \
-               or obj.email_digest.filter(id=user_id).exists()
+        return obj.user == request.user

api/subscriptions/serializers.py

@@ -1,58 +1,43 @@
+from django.contrib.contenttypes.models import ContentType
 from rest_framework import serializers as ser
-from rest_framework.exceptions import ValidationError
 from api.nodes.serializers import RegistrationProviderRelationshipField
 from api.collections_providers.fields import CollectionProviderRelationshipField
 from api.preprints.serializers import PreprintProviderRelationshipField
+from osf.models import Node
 from website.util import api_v2_url
 
 
-from api.base.serializers import JSONAPISerializer, LinksField
-
-NOTIFICATION_TYPES = {
-    'none': 'none',
-    'instant': 'email_transactional',
-    'daily': 'email_digest',
-}
-
-
-class FrequencyField(ser.Field):
-    def to_representation(self, obj):
-        user_id = self.context['request'].user.id
-        if obj.email_transactional.filter(id=user_id).exists():
-            return 'instant'
-        if obj.email_digest.filter(id=user_id).exists():
-            return 'daily'
-        return 'none'
-
-    def to_internal_value(self, frequency):
-        notification_type = NOTIFICATION_TYPES.get(frequency)
-        if notification_type:
-            return {'notification_type': notification_type}
-        raise ValidationError(f'Invalid frequency "{frequency}"')
+from api.base.serializers import JSONAPISerializer
+from .fields import FrequencyField
 
 class SubscriptionSerializer(JSONAPISerializer):
     filterable_fields = frozenset([
         'id',
         'event_name',
+        'frequency',
     ])
 
-    id = ser.CharField(source='_id', read_only=True)
+    id = ser.CharField(read_only=True)
     event_name = ser.CharField(read_only=True)
     frequency = FrequencyField(source='*', required=True)
-    links = LinksField({
-        'self': 'get_absolute_url',
-    })
 
     class Meta:
         type_ = 'subscription'
 
-    def get_absolute_url(self, obj):
-        return obj.absolute_api_v2_url
-
     def update(self, instance, validated_data):
         user = self.context['request'].user
-        notification_type = validated_data.get('notification_type')
-        instance.add_user_to_subscription(user, notification_type, save=True)
+        frequency = validated_data.get('frequency')
+
+        if frequency != 'none' and instance.content_type == ContentType.objects.get_for_model(Node):
+            node = Node.objects.get(
+                id=instance.id,
+                content_type=instance.content_type,
+            )
+            user_subs = node.parent_node.child_node_subscriptions
+            if node._id not in user_subs.setdefault(user._id, []):
+                user_subs[user._id].append(node._id)
+                node.parent_node.save()
+
         return instance
 
 

api/subscriptions/views.py

@@ -1,8 +1,8 @@
+from pyasn1_modules.rfc5126 import ContentType
 from rest_framework import generics
 from rest_framework import permissions as drf_permissions
 from rest_framework.exceptions import NotFound
 from django.core.exceptions import ObjectDoesNotExist
-from django.db.models import Q
 
 from framework.auth.oauth_scopes import CoreScopes
 from api.base.views import JSONAPIBaseView
@@ -16,12 +16,12 @@
 )
 from api.subscriptions.permissions import IsSubscriptionOwner
 from osf.models import (
-    NotificationSubscription,
     CollectionProvider,
     PreprintProvider,
     RegistrationProvider,
     AbstractProvider,
 )
+from osf.models.notification import NotificationSubscription
 
 
 class SubscriptionList(JSONAPIBaseView, generics.ListAPIView, ListFilterMixin):
@@ -37,32 +37,20 @@ class SubscriptionList(JSONAPIBaseView, generics.ListAPIView, ListFilterMixin):
     required_read_scopes = [CoreScopes.SUBSCRIPTIONS_READ]
     required_write_scopes = [CoreScopes.NULL]
 
-    def get_default_queryset(self):
-        user = self.request.user
-        return NotificationSubscription.objects.filter(
-            Q(none=user) |
-            Q(email_digest=user) |
-            Q(
-                email_transactional=user,
-            ),
-        ).distinct()
-
     def get_queryset(self):
-        return self.get_queryset_from_request()
+        return NotificationSubscription.objects.filter(
+            user=self.request.user,
+        )
 
 
 class AbstractProviderSubscriptionList(SubscriptionList):
-    def get_default_queryset(self):
-        user = self.request.user
+    def get_queryset(self):
+        provider = AbstractProvider.objects.get(_id=self.kwargs['provider_id'])
         return NotificationSubscription.objects.filter(
-            provider___id=self.kwargs['provider_id'],
-            provider__type=self.provider_class._typedmodels_type,
-        ).filter(
-            Q(none=user) |
-            Q(email_digest=user) |
-            Q(email_transactional=user),
-        ).distinct()
-
+            object_id=provider,
+            provider__type=ContentType.objects.get_for_model(provider.__class__),
+            user=self.request.user,
+        )
 
 class SubscriptionDetail(JSONAPIBaseView, generics.RetrieveUpdateAPIView):
     view_name = 'notification-subscription-detail'
@@ -80,7 +68,7 @@ class SubscriptionDetail(JSONAPIBaseView, generics.RetrieveUpdateAPIView):
     def get_object(self):
         subscription_id = self.kwargs['subscription_id']
         try:
-            obj = NotificationSubscription.objects.get(_id=subscription_id)
+            obj = NotificationSubscription.objects.get(id=subscription_id)
         except ObjectDoesNotExist:
             raise NotFound
         self.check_object_permissions(self.request, obj)
@@ -100,33 +88,6 @@ class AbstractProviderSubscriptionDetail(SubscriptionDetail):
     required_write_scopes = [CoreScopes.SUBSCRIPTIONS_WRITE]
     provider_class = None
 
-    def __init__(self, *args, **kwargs):
-        assert issubclass(self.provider_class, AbstractProvider), 'Class must be subclass of AbstractProvider'
-        super().__init__(*args, **kwargs)
-
-    def get_object(self):
-        subscription_id = self.kwargs['subscription_id']
-        if self.kwargs.get('provider_id'):
-            provider = self.provider_class.objects.get(_id=self.kwargs.get('provider_id'))
-            try:
-                obj = NotificationSubscription.objects.get(
-                    _id=subscription_id,
-                    provider_id=provider.id,
-                )
-            except ObjectDoesNotExist:
-                raise NotFound
-        else:
-            try:
-                obj = NotificationSubscription.objects.get(
-                    _id=subscription_id,
-                    provider__type=self.provider_class._typedmodels_type,
-                )
-            except ObjectDoesNotExist:
-                raise NotFound
-        self.check_object_permissions(self.request, obj)
-        return obj
-
-
 class CollectionProviderSubscriptionDetail(AbstractProviderSubscriptionDetail):
     provider_class = CollectionProvider
     serializer_class = CollectionSubscriptionSerializer