dev: email notifications

apiserver/plane/app/serializers/__init__.py

@@ -114,7 +114,7 @@
 
 from .analytic import AnalyticViewSerializer
 
-from .notification import NotificationSerializer
+from .notification import NotificationSerializer, UserNotificationPreferenceSerializer
 
 from .exporter import ExporterHistorySerializer
 

apiserver/plane/app/serializers/notification.py

@@ -1,7 +1,7 @@
 # Module imports
 from .base import BaseSerializer
 from .user import UserLiteSerializer
-from plane.db.models import Notification
+from plane.db.models import Notification, UserNotificationPreference
 
 
 class NotificationSerializer(BaseSerializer):
@@ -12,3 +12,10 @@ class NotificationSerializer(BaseSerializer):
     class Meta:
         model = Notification
         fields = "__all__"
+
+
+class UserNotificationPreferenceSerializer(BaseSerializer):
+
+    class Meta:
+        model = UserNotificationPreference
+        fields = "__all__"

apiserver/plane/app/urls/notification.py

@@ -5,6 +5,7 @@
     NotificationViewSet,
     UnreadNotificationEndpoint,
     MarkAllReadNotificationViewSet,
+    UserNotificationPreferenceEndpoint,
 )
 
 
@@ -63,4 +64,9 @@
         ),
         name="mark-all-read-notifications",
     ),
+    path(
+        "users/me/notification-preferences/",
+        UserNotificationPreferenceEndpoint.as_view(),
+        name="user-notification-preferences",
+    ),
 ]

apiserver/plane/app/views/__init__.py

@@ -165,6 +165,7 @@
     NotificationViewSet,
     UnreadNotificationEndpoint,
     MarkAllReadNotificationViewSet,
+    UserNotificationPreferenceEndpoint,
 )
 
 from .exporter import ExportIssuesEndpoint

apiserver/plane/app/views/notification.py

@@ -1,5 +1,5 @@
 # Django imports
-from django.db.models import Q
+from django.db.models import Q, OuterRef, Exists
 from django.utils import timezone
 
 # Third party imports
@@ -15,8 +15,9 @@
     IssueSubscriber,
     Issue,
     WorkspaceMember,
+    UserNotificationPreference,
 )
-from plane.app.serializers import NotificationSerializer
+from plane.app.serializers import NotificationSerializer, UserNotificationPreferenceSerializer
 
 
 class NotificationViewSet(BaseViewSet, BasePaginator):
@@ -71,11 +72,29 @@ def list(self, request, slug):
 
         # Subscribed issues
         if type == "watching":
-            issue_ids = IssueSubscriber.objects.filter(
-                workspace__slug=slug, subscriber_id=request.user.id
-            ).values_list("issue_id", flat=True)
+            issue_ids = (
+                IssueSubscriber.objects.filter(
+                    workspace__slug=slug, subscriber_id=request.user.id
+                )
+                .annotate(
+                    created=Exists(
+                        Issue.objects.filter(
+                            created_by=request.user, pk=OuterRef("issue_id")
+                        )
+                    )
+                )
+                .annotate(
+                    assigned=Exists(
+                        IssueAssignee.objects.filter(
+                            pk=OuterRef("issue_id"), assignee=request.user
+                        )
+                    )
+                )
+                .filter(created=False, assigned=False)
+                .values_list("issue_id", flat=True)
+            )
             notifications = notifications.filter(
-                entity_identifier__in=issue_ids
+                entity_identifier__in=issue_ids,
             )
 
         # Assigned Issues
@@ -295,3 +314,31 @@ def create(self, request, slug):
             updated_notifications, ["read_at"], batch_size=100
         )
         return Response({"message": "Successful"}, status=status.HTTP_200_OK)
+
+
+class UserNotificationPreferenceEndpoint(BaseAPIView):
+    model = UserNotificationPreference
+    serializer_class = UserNotificationPreferenceSerializer
+
+    # request the object
+    def get(self, request):
+        user_notification_preference = UserNotificationPreference.objects.get(
+            user=request.user
+        )
+        serializer = UserNotificationPreferenceSerializer(
+            user_notification_preference
+        )
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    # update the object
+    def patch(self, request):
+        user_notification_preference = UserNotificationPreference.objects.get(
+            user=request.user
+        )
+        serializer = UserNotificationPreferenceSerializer(
+            user_notification_preference, data=request.data, partial=True
+        )
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

apiserver/plane/bgtasks/email_notification_task.py

@@ -0,0 +1,209 @@
+# Third party imports
+from celery import shared_task
+import os
+
+# Django imports
+from django.utils import timezone
+from django.core.mail import EmailMultiAlternatives, get_connection
+from django.template.loader import render_to_string
+from django.utils.html import strip_tags
+
+# Module imports
+from plane.db.models import EmailNotificationLog, User, Issue
+from plane.license.utils.instance_value import get_email_configuration
+
+
+@shared_task
+def stack_email_notification():
+    # get all email notifications
+    email_notifications = (
+        EmailNotificationLog.objects.filter(processed_at__isnull=True)
+        .order_by("receiver")
+        .values()
+    )
+
+    # Create the below format for each of the issues
+    # {"issue_id" : { "actor_id1": [ { data }, { data } ], "actor_id2": [ { data }, { data } ] }}
+
+    # Convert to unique receivers list
+    receivers = list(
+        set(
+            [
+                str(notification.get("receiver_id"))
+                for notification in email_notifications
+            ]
+        )
+    )
+    processed_notifications = []
+    # Loop through all the issues to create the emails
+    for receiver_id in receivers:
+        # Notifcation triggered for the receiver
+        receiver_notifications = [
+            notification
+            for notification in email_notifications
+            if str(notification.get("receiver_id")) == receiver_id
+        ]
+        # create payload for all issues
+        payload = {}
+        email_notification_ids = []
+        for receiver_notification in receiver_notifications:
+            payload.setdefault(
+                receiver_notification.get("entity_identifier"), {}
+            ).setdefault(
+                str(receiver_notification.get("triggered_by_id")), []
+            ).append(
+                receiver_notification.get("data")
+            )
+            # append processed notifications
+            processed_notifications.append(receiver_notification.get("id"))
+            email_notification_ids.append(receiver_notification.get("id"))
+
+        # Create emails for all the issues
+        for issue_id, notification_data in payload.items():
+            send_email_notification.delay(
+                issue_id=issue_id,
+                notification_data=notification_data,
+                receiver_id=receiver_id,
+                email_notification_ids=email_notification_ids,
+            )
+
+    # Update the email notification log
+    EmailNotificationLog.objects.filter(pk__in=processed_notifications).update(
+        processed_at=timezone.now()
+    )
+
+
+def create_payload(notification_data):
+    # return format {"actor_id":  { "key": { "old_value": [], "new_value": [] } }}
+    data = {}
+    for actor_id, changes in notification_data.items():
+        for change in changes:
+            issue_activity = change.get("issue_activity")
+            if issue_activity:  # Ensure issue_activity is not None
+                field = issue_activity.get("field")
+                old_value = issue_activity.get("old_value")
+                new_value = issue_activity.get("new_value")
+
+                # Append old_value if it's not empty and not already in the list
+                if old_value:
+                    data.setdefault(actor_id, {}).setdefault(
+                        field, {}
+                    ).setdefault("old_value", []).append(
+                        old_value
+                    ) if old_value not in data.setdefault(
+                        actor_id, {}
+                    ).setdefault(
+                        field, {}
+                    ).get(
+                        "old_value", []
+                    ) else None
+
+                # Append new_value if it's not empty and not already in the list
+                if new_value:
+                    data.setdefault(actor_id, {}).setdefault(
+                        field, {}
+                    ).setdefault("new_value", []).append(
+                        new_value
+                    ) if new_value not in data.setdefault(
+                        actor_id, {}
+                    ).setdefault(
+                        field, {}
+                    ).get(
+                        "new_value", []
+                    ) else None
+
+    return data
+
+
+@shared_task
+def send_email_notification(
+    issue_id, notification_data, receiver_id, email_notification_ids
+):
+    base_api = "http://localhost:3000"
+    data = create_payload(notification_data=notification_data)
+
+    # Get email configurations
+    (
+        EMAIL_HOST,
+        EMAIL_HOST_USER,
+        EMAIL_HOST_PASSWORD,
+        EMAIL_PORT,
+        EMAIL_USE_TLS,
+        EMAIL_FROM,
+    ) = get_email_configuration()
+
+    receiver = User.objects.get(pk=receiver_id)
+    issue = Issue.objects.get(pk=issue_id)
+    template_data = []
+    total_changes = 0
+    for actor_id, changes in data.items():
+        actor = User.objects.get(pk=actor_id)
+        total_changes = total_changes + len(changes)
+        template_data.append(
+            {
+                "actor_detail": {
+                    "avatar": actor.avatar,
+                    "first_name": actor.first_name,
+                    "last_name": actor.last_name,
+                },
+                "changes": changes,
+                "issue_details": {
+                    "name": issue.name,
+                    "identifier": f"{issue.project.identifier}-{issue.sequence_id}",
+                },
+            }
+        )
+
+    summary = ""
+    if len(template_data) == 1:
+        summary = f"{template_data[0]['actor_detail']['first_name']} {template_data[0]['actor_detail']['last_name']} made {total_changes} changes to the issue"
+    else:
+        summary = f"{template_data[0]['actor_detail']['first_name']} {template_data[0]['actor_detail']['last_name']} and others made {total_changes} changes to the issue"
+
+    # Send the mail
+    subject = f"{issue.project.identifier}-{issue.sequence_id} {issue.name}"
+    context = {
+        "data": template_data,
+        "summary": summary,
+        "issue": {
+            "issue_identifier": f"{str(issue.project.identifier)}-{str(issue.sequence_id)}",
+            "name": issue.name,
+        },
+        "receiver": {
+            "email": receiver.email,
+        },
+        "issue_unsubscribe": f"{base_api}/{str(issue.project.workspace.slug)}/projects/{str(issue.project.id)}/issues/{str(issue.id)}",
+        "user_preference": f"{base_api}/profile/preferences/email"
+    }
+    html_content = render_to_string(
+        "emails/notifications/issue-updates.html", context
+    )
+    text_content = strip_tags(html_content)
+
+    try:
+        connection = get_connection(
+            host=EMAIL_HOST,
+            port=int(EMAIL_PORT),
+            username=EMAIL_HOST_USER,
+            password=EMAIL_HOST_PASSWORD,
+            use_tls=EMAIL_USE_TLS == "1",
+        )
+
+        msg = EmailMultiAlternatives(
+            subject=subject,
+            body=text_content,
+            from_email=EMAIL_FROM,
+            to=[receiver.email],
+            connection=connection,
+        )
+        msg.attach_alternative(html_content, "text/html")
+        msg.send()
+
+        EmailNotificationLog.objects.filter(
+            pk__in=email_notification_ids
+        ).update(sent_at=timezone.now())
+        print("Email Sent")
+        return
+    except Exception as e:
+        print(e)
+        return

apiserver/plane/bgtasks/importer_task.py

@@ -24,6 +24,7 @@
     Label,
     User,
     IssueProperty,
+    UserNotificationPreference,
 )
 
 
@@ -50,10 +51,24 @@ def service_importer(service, importer_id):
                     for user in users
                     if user.get("import", False) == "invite"
                 ],
-                batch_size=10,
+                batch_size=100,
                 ignore_conflicts=True,
             )
 
+            _ = UserNotificationPreference.objects.bulk_create(
+                [UserNotificationPreference(user=user) for user in new_users],
+                batch_size=100,
+            )
+
+            _ = [
+                send_welcome_slack.delay(
+                    str(user.id),
+                    True,
+                    f"{user.email} was imported to Plane from {service}",
+                )
+                for user in new_users
+            ]
+
             workspace_users = User.objects.filter(
                 email__in=[
                     user.get("email").strip().lower()