[ENG-8087] Upgrade User Confirmation Registrations

admin/base/settings/defaults.py

@@ -40,7 +40,7 @@
 CSRF_COOKIE_HTTPONLY = False
 
 ALLOWED_HOSTS = [
-    '.osf.io',
+    '.osf.io'
 ]
 
 AUTH_PASSWORD_VALIDATORS = [

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/institutions/authentication.py

@@ -20,10 +20,10 @@
 
 from osf import features
 from osf.exceptions import InstitutionAffiliationStateError
-from osf.models import Institution
+from osf.models import Institution, NotificationType
 from osf.models.institution import SsoFilterCriteriaAction
 
-from website.mails import send_mail, WELCOME_OSF4I, DUPLICATE_ACCOUNTS_OSF4I, ADD_SSO_EMAIL_OSF4I
+from website.mails import send_mail, DUPLICATE_ACCOUNTS_OSF4I, ADD_SSO_EMAIL_OSF4I
 from website.settings import OSF_SUPPORT_EMAIL, DOMAIN
 from website.util.metrics import institution_source_tag
 
@@ -334,13 +334,15 @@ def authenticate(self, request):
             user.save()
 
             # Send confirmation email for all three: created, confirmed and claimed
-            send_mail(
-                to_addr=user.username,
-                mail=WELCOME_OSF4I,
+            notification_type = NotificationType.objects.get(name=NotificationType.Type.USER_WELCOME_OSF4I.value)
+            notification_type.emit(
                 user=user,
-                domain=DOMAIN,
-                osf_support_email=OSF_SUPPORT_EMAIL,
-                storage_flag_is_active=flag_is_active(request, features.STORAGE_I18N),
+                message_frequency='instantly',
+                event_context={
+                    'domain': DOMAIN,
+                    'osf_support_email': OSF_SUPPORT_EMAIL,
+                    'storage_flag_is_active': flag_is_active(request, features.STORAGE_I18N),
+                },
             )
 
         # Add the email to the user's account if it is identified by the eppn

api/subscriptions/fields.py

@@ -0,0 +1,11 @@
+from rest_framework import serializers as ser
+
+class FrequencyField(ser.ChoiceField):
+    def __init__(self, **kwargs):
+        super().__init__(choices=['none', 'instantly', 'daily', 'weekly', 'monthly'], **kwargs)
+
+    def to_representation(self, frequency: str):
+        return frequency or 'none'
+
+    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_subscription 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,55 @@
+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 .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,
+        source='legacy_id',
+        help_text='The id of the subscription fixed for backward compatibility',
+    )
     event_name = ser.CharField(read_only=True)
-    frequency = FrequencyField(source='*', required=True)
-    links = LinksField({
-        'self': 'get_absolute_url',
-    })
+    frequency = FrequencyField(source='message_frequency', required=True)
 
     class Meta:
         type_ = 'subscription'
 
+    links = LinksField({
+        'self': 'get_absolute_url',
+    })
+
     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') or 'none'
+        instance.message_frequency = 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