feat: added reported notification type

feat: added new notification for reported content

feat: added reported notifications

feat: added reported notifications

lms/djangoapps/discussion/rest_api/discussions_notifications.py

@@ -2,6 +2,7 @@
 Discussion notifications sender util.
 """
 import logging
+import re
 
 from django.conf import settings
 from lms.djangoapps.discussion.django_comment_client.permissions import get_team
@@ -21,7 +22,6 @@
     CourseDiscussionSettings,
 )
 
-
 log = logging.getLogger(__name__)
 
 
@@ -75,7 +75,7 @@ def _send_course_wide_notification(self, notification_type, audience_filters=Non
             course_key=self.course.id,
             content_context={
                 "replier_name": self.creator.username,
-                "post_title": self.thread.title,
+                "post_title": getattr(self.thread, 'title', ''),
                 "course_name": self.course.display_name,
                 "sender_id": self.creator.id,
                 **extra_context,
@@ -147,7 +147,7 @@ def send_new_comment_on_response_notification(self):
         if (
             self.parent_response and
             self.creator.id != int(self.parent_response.user_id) and not
-            self._response_and_thread_has_same_creator()
+        self._response_and_thread_has_same_creator()
         ):
             self._send_notification([self.parent_response.user_id], "new_comment_on_response")
 
@@ -206,16 +206,20 @@ def _create_cohort_course_audience(self):
         discussion_cohorted = is_discussion_cohorted(course_key_str)
 
         # Retrieves cohort divided discussion
-        discussion_settings = CourseDiscussionSettings.objects.get(course_id=course_key_str)
+        try:
+            discussion_settings = CourseDiscussionSettings.objects.get(course_id=course_key_str)
+        except CourseDiscussionSettings.DoesNotExist:
+            return {}
         divided_course_wide_discussions, divided_inline_discussions = get_divided_discussions(
             self.course,
             discussion_settings
         )
 
         # Checks if post has any cohort assigned
-        group_id = self.thread.attributes['group_id']
-        if group_id is not None:
-            group_id = int(group_id)
+        group_id = self.thread.attributes.get('group_id')
+        if group_id is None:
+            return {}
+        group_id = int(group_id)
 
         # Course wide topics
         all_topics = divided_inline_discussions + divided_course_wide_discussions
@@ -266,11 +270,50 @@ def send_new_thread_created_notification(self):
         log.info(f"Temp: Audience filter for course-wide notification is {audience_filters}")
         self._send_course_wide_notification(notification_type, audience_filters, context)
 
+    def send_reported_content_notification(self):
+        """
+        Send notification to users who are subscribed to the thread.
+        """
+        thread_body = self.thread.body if self.thread.body else ''
+
+        thread_body = remove_html_tags(thread_body)
+        thread_types = {
+            # numeric key is the depth of the thread in the discussion
+            'comment': {
+                1: 'comment',
+                0: 'response'
+            },
+            'thread': {
+                0: 'thread'
+            }
+        }
+
+        content_type = thread_types[self.thread.type][getattr(self.thread, 'depth', 0)]
+
+        context = {
+            'username': self.creator.username,
+            'content_type': content_type,
+            'content': thread_body
+        }
+        audience_filters = self._create_cohort_course_audience()
+        audience_filters['discussion_roles'] = [
+            FORUM_ROLE_ADMINISTRATOR, FORUM_ROLE_MODERATOR, FORUM_ROLE_COMMUNITY_TA
+        ]
+        self._send_course_wide_notification("content_reported", audience_filters, context)
+
 
 def is_discussion_cohorted(course_key_str):
     """
     Returns if the discussion is divided by cohorts
     """
-    cohort_settings = CourseCohortsSettings.objects.get(course_id=course_key_str)
-    discussion_settings = CourseDiscussionSettings.objects.get(course_id=course_key_str)
+    try:
+        cohort_settings = CourseCohortsSettings.objects.get(course_id=course_key_str)
+        discussion_settings = CourseDiscussionSettings.objects.get(course_id=course_key_str)
+    except (CourseCohortsSettings.DoesNotExist, CourseDiscussionSettings.DoesNotExist):
+        return False
     return cohort_settings.is_cohorted and discussion_settings.always_divide_inline_discussions
+
+
+def remove_html_tags(text):
+    clean = re.compile('<.*?>')
+    return re.sub(clean, '', text)

lms/djangoapps/discussion/rest_api/tests/test_disucssions_notifications.py

@@ -0,0 +1,85 @@
+"""
+Unit tests for the DiscussionNotificationSender class
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+
+from lms.djangoapps.discussion.rest_api.discussions_notifications import DiscussionNotificationSender
+
+
+@patch('lms.djangoapps.discussion.rest_api.discussions_notifications.DiscussionNotificationSender'
+       '._create_cohort_course_audience', return_value={})
+@patch('lms.djangoapps.discussion.rest_api.discussions_notifications.DiscussionNotificationSender'
+       '._send_course_wide_notification')
+class TestDiscussionNotificationSender(unittest.TestCase):
+    """
+    Tests for the DiscussionNotificationSender class
+    """
+
+    def setUp(self):
+        self.thread = MagicMock()
+        self.course = MagicMock()
+        self.creator = MagicMock()
+        self.notification_sender = DiscussionNotificationSender(self.thread, self.course, self.creator)
+
+    def _setup_thread(self, thread_type, body, depth):
+        """
+        Helper to set up the thread object
+        """
+        self.thread.type = thread_type
+        self.thread.body = body
+        self.thread.depth = depth
+        self.creator.username = 'test_user'
+
+    def _assert_send_notification_called_with(self, mock_send_notification, expected_content_type):
+        """
+        Helper to assert that the send_notification method was called with the correct arguments
+        """
+        notification_type, audience_filters, context = mock_send_notification.call_args[0]
+        mock_send_notification.assert_called_once()
+
+        self.assertEqual(notification_type, "content_reported")
+        self.assertEqual(context, {
+            'username': 'test_user',
+            'content_type': expected_content_type,
+            'content': 'Thread body'
+        })
+        self.assertEqual(audience_filters, {
+            'discussion_roles': ['Administrator', 'Moderator', 'Community TA']
+        })
+
+    def test_send_reported_content_notification_for_response(self, mock_send_notification, mock_create_audience):
+        """
+        Test that the send_reported_content_notification method calls the send_notification method with the correct
+        arguments for a comment with depth 0
+        """
+        self._setup_thread('comment', '<p>Thread body</p>', 0)
+        mock_create_audience.return_value = {}
+
+        self.notification_sender.send_reported_content_notification()
+
+        self._assert_send_notification_called_with(mock_send_notification, 'response')
+
+    def test_send_reported_content_notification_for_comment(self, mock_send_notification, mock_create_audience):
+        """
+        Test that the send_reported_content_notification method calls the send_notification method with the correct
+        arguments for a comment with depth 1
+        """
+        self._setup_thread('comment', '<p>Thread body</p>', 1)
+        mock_create_audience.return_value = {}
+
+        self.notification_sender.send_reported_content_notification()
+
+        self._assert_send_notification_called_with(mock_send_notification, 'comment')
+
+    def test_send_reported_content_notification_for_thread(self, mock_send_notification, mock_create_audience):
+        """
+        Test that the send_reported_content_notification method calls the send_notification method with the correct
+        """
+        self._setup_thread('thread', '<p>Thread body</p>', 0)
+        mock_create_audience.return_value = {}
+
+        self.notification_sender.send_reported_content_notification()
+
+        self._assert_send_notification_called_with(mock_send_notification, 'thread')

lms/djangoapps/discussion/signals/handlers.py

@@ -2,14 +2,17 @@
 Signal handlers related to discussions.
 """
 
-
 import logging
 
 from django.conf import settings
 from django.dispatch import receiver
 from django.utils.html import strip_tags
+from opaque_keys.edx.keys import CourseKey
 from opaque_keys.edx.locator import LibraryLocator
-from xmodule.modulestore.django import SignalHandler
+
+from lms.djangoapps.discussion.rest_api.discussions_notifications import DiscussionNotificationSender
+from lms.djangoapps.discussion.toggles_utils import reported_content_email_notification_enabled
+from xmodule.modulestore.django import SignalHandler, modulestore
 
 from lms.djangoapps.discussion import tasks
 from lms.djangoapps.discussion.rest_api.tasks import send_response_notifications, send_thread_created_notification
@@ -19,7 +22,6 @@
 
 log = logging.getLogger(__name__)
 
-
 ENABLE_FORUM_NOTIFICATIONS_FOR_SITE_KEY = 'enable_forum_notifications'
 
 
@@ -43,7 +45,8 @@ def update_discussions_on_course_publish(sender, course_key, **kwargs):  # pylin
 
 
 @receiver(signals.comment_created)
-def send_discussion_email_notification(sender, user, post, **kwargs):  # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
+def send_discussion_email_notification(sender, user, post,
+                                       **kwargs):  # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
     current_site = get_current_site()
     if current_site is None:
         log.info('Discussion: No current site, not sending notification about post: %s.', post.id)
@@ -64,7 +67,13 @@ def send_discussion_email_notification(sender, user, post, **kwargs):  # lint-am
 
 @receiver(signals.comment_flagged)
 @receiver(signals.thread_flagged)
-def send_reported_content_email_notification(sender, user, post, **kwargs):  # lint-amnesty, pylint: disable=missing-function-docstring, unused-argument
+def send_reported_content_email_notification(sender, user, post, **kwargs):
+    """
+    Sends email notification for reported content.
+    """
+    course_key = CourseKey.from_string(post.course_id)
+    if not reported_content_email_notification_enabled(course_key):
+        return
     current_site = get_current_site()
     if current_site is None:
         log.info('Discussion: No current site, not sending notification about post: %s.', post.id)
@@ -84,6 +93,17 @@ def send_reported_content_email_notification(sender, user, post, **kwargs):  # l
     send_message_for_reported_content(user, post, current_site, sender)
 
 
+@receiver(signals.comment_flagged)
+@receiver(signals.thread_flagged)
+def send_reported_content_notification(sender, user, post, **kwargs):
+    """
+    Sends notification for reported content.
+    """
+    course_key = CourseKey.from_string(post.course_id)
+    course = modulestore().get_course(course_key)
+    DiscussionNotificationSender(post, course, user).send_reported_content_notification()
+
+
 def create_message_context(comment, site):
     thread = comment.thread
     return {
@@ -105,6 +125,7 @@ def create_message_context_for_reported_content(user, post, site, sender):
     """
     Create message context for reported content.
     """
+
     def get_comment_type(comment):
         """
         Returns type of comment.
@@ -131,7 +152,8 @@ def send_message(comment, site):  # lint-amnesty, pylint: disable=missing-functi
     tasks.send_ace_message.apply_async(args=[context])
 
 
-def send_message_for_reported_content(user, post, site, sender):  # lint-amnesty, pylint: disable=missing-function-docstring
+def send_message_for_reported_content(user, post, site,
+                                      sender):  # lint-amnesty, pylint: disable=missing-function-docstring
     context = create_message_context_for_reported_content(user, post, site, sender)
     tasks.send_ace_message_for_reported_content.apply_async(args=[context], countdown=120)
 

openedx/core/djangoapps/notifications/base_notification.py

@@ -113,6 +113,25 @@
         'email_template': '',
         'filters': [FILTER_AUDIT_EXPIRED_USERS_WITH_NO_ROLE]
     },
+    'content_reported': {
+        'notification_app': 'discussion',
+        'name': 'content_reported',
+        'is_core': False,
+        'info': '',
+        'web': True,
+        'email': True,
+        'push': True,
+        'non_editable': [],
+        'content_template': _('<p><strong>{username}’s </strong> {content_type} has been reported <strong> {'
+                              'content}</strong></p>'),
+
+        'content_context': {
+            'post_title': 'Post title',
+            'author_name': 'author name',
+            'replier_name': 'replier name',
+        },
+        'email_template': '',
+    },
 }
 
 COURSE_NOTIFICATION_APPS = {

openedx/core/djangoapps/notifications/models.py

@@ -21,7 +21,7 @@
 NOTIFICATION_CHANNELS = ['web', 'push', 'email']
 
 # Update this version when there is a change to any course specific notification type or app.
-COURSE_NOTIFICATION_CONFIG_VERSION = 4
+COURSE_NOTIFICATION_CONFIG_VERSION = 5
 
 
 def get_course_notification_preference_config():

openedx/core/djangoapps/notifications/tests/test_views.py

@@ -246,6 +246,7 @@ def _expected_api_response(self, course=None):
                         },
                         'new_discussion_post': {'web': False, 'email': False, 'push': False, 'info': ''},
                         'new_question_post': {'web': False, 'email': False, 'push': False, 'info': ''},
+                        'content_reported': {'web': True, 'email': True, 'push': True, 'info': ''},
                     },
                     'non_editable': {
                         'core': ['web']