Add send_and_delete to the scheduler classes to have one scheduled job only for the once recurring reminder

Author: ahmedxgouda

backend/apps/nest/schedulers/calendar_events/base.py

@@ -1,6 +1,5 @@
 """Base Scheduler for Nest Calendar Events."""
 
-from django.utils import timezone
 from django_rq import get_scheduler
 
 from apps.nest.models.reminder_schedule import ReminderSchedule
@@ -19,16 +18,11 @@ def schedule(self):
         if self.reminder_schedule.recurrence == ReminderSchedule.Recurrence.ONCE:
             self.reminder_schedule.job_id = self.scheduler.enqueue_at(
                 self.reminder_schedule.scheduled_time,
-                self.__class__.send_message,
+                self.__class__.send_and_delete,
                 message=self.reminder_schedule.reminder.message,
                 channel_id=self.reminder_schedule.reminder.channel_id,
+                reminder_schedule_id=self.reminder_schedule.pk,
             ).get_id()
-
-            # Schedule deletion of the reminder after sending the message
-            self.scheduler.enqueue_at(
-                self.reminder_schedule.scheduled_time + timezone.timedelta(minutes=1),
-                self.reminder_schedule.reminder.delete,
-            )
         else:
             self.reminder_schedule.job_id = self.scheduler.cron(
                 self.reminder_schedule.cron_expression,
@@ -52,8 +46,8 @@ def cancel(self):
             self.reminder_schedule.reminder.delete()
 
     @staticmethod
-    def send_message(message: str, channel_id: str):
-        """Send message to the specified channel. To be implemented by subclasses."""
+    def send_and_delete(message: str, channel_id: str, reminder_schedule_id: int):
+        """Send message to the specified channel and delete the reminder."""
         error_message = "Subclasses must implement this method."
         raise NotImplementedError(error_message)
 
@@ -62,3 +56,9 @@ def send_and_update(message: str, channel_id: str, reminder_schedule_id: int):
         """Send message and update the reminder schedule."""
         error_message = "Subclasses must implement this method."
         raise NotImplementedError(error_message)
+
+    @staticmethod
+    def send_message(message: str, channel_id: str):
+        """Send message to the specified channel."""
+        error_message = "Subclasses must implement this method."
+        raise NotImplementedError(error_message)

backend/apps/nest/schedulers/calendar_events/slack.py

@@ -17,6 +17,16 @@ def send_message(message: str, channel_id: str):
                 text=message,
             )
 
+    @staticmethod
+    def send_and_delete(message: str, channel_id: str, reminder_schedule_id: int):
+        """Send message to the specified channel and delete the reminder."""
+        # Import here to avoid circular import issues
+        from apps.nest.models.reminder_schedule import ReminderSchedule
+
+        SlackScheduler.send_message(message, channel_id)
+        if reminder_schedule := ReminderSchedule.objects.filter(pk=reminder_schedule_id).first():
+            reminder_schedule.reminder.delete()
+
     @staticmethod
     def send_and_update(message: str, channel_id: str, reminder_schedule_id: int):
         """Send message and update the reminder schedule."""

backend/tests/apps/nest/schedulers/calendar_events/base_test.py

@@ -32,22 +32,20 @@ def test_schedule_once(self, mock_get_scheduler):
         mock_reminder_schedule.scheduled_time = timezone.datetime(2024, 10, 10, 10, 0, 0)
         mock_reminder_schedule.reminder.message = "Test Message"
         mock_reminder_schedule.reminder.channel_id = "C123456"
+        mock_reminder_schedule.pk = 4
 
         scheduler_instance = MagicMock()
         mock_get_scheduler.return_value = scheduler_instance
 
         base_scheduler = BaseScheduler(reminder_schedule=mock_reminder_schedule)
         base_scheduler.schedule()
 
-        scheduler_instance.enqueue_at.assert_any_call(
+        scheduler_instance.enqueue_at.assert_called_once_with(
             mock_reminder_schedule.scheduled_time,
-            BaseScheduler.send_message,
+            BaseScheduler.send_and_delete,
             message="Test Message",
             channel_id="C123456",
-        )
-        scheduler_instance.enqueue_at.assert_any_call(
-            mock_reminder_schedule.scheduled_time + timezone.timedelta(minutes=1),
-            mock_reminder_schedule.reminder.delete,
+            reminder_schedule_id=mock_reminder_schedule.pk,
         )
         mock_reminder_schedule.save.assert_called_once_with(update_fields=["job_id"])
 
@@ -99,8 +97,14 @@ def test_send_message_not_implemented(self):
             BaseScheduler.send_message("Test Message", "C123456")
         assert str(exc_info.value) == "Subclasses must implement this method."
 
+    def test_send_and_delete_not_implemented(self):
+        """Test that send_and_delete raises NotImplementedError."""
+        with pytest.raises(NotImplementedError) as exc_info:
+            BaseScheduler.send_and_delete("Test Message", "C123456", 4)
+        assert str(exc_info.value) == "Subclasses must implement this method."
+
     def test_send_and_update_not_implemented(self):
         """Test that send_and_update raises NotImplementedError."""
         with pytest.raises(NotImplementedError) as exc_info:
-            BaseScheduler.send_and_update("Test Message", "C123456", MagicMock())
+            BaseScheduler.send_and_update("Test Message", "C123456", 4)
         assert str(exc_info.value) == "Subclasses must implement this method."

backend/tests/apps/nest/schedulers/calendar_events/slack_test.py

@@ -20,6 +20,18 @@ def test_send_message(self, mock_slack_config):
             text="Test Message",
         )
 
+    @patch("apps.nest.schedulers.calendar_events.slack.SlackScheduler.send_message")
+    @patch("apps.nest.models.reminder_schedule.ReminderSchedule.objects.filter")
+    def test_send_and_delete(self, mock_filter, mock_send_message):
+        """Test sending a message and deleting it via Slack."""
+        mock_schedule = MagicMock()
+        mock_filter.return_value.first.return_value = mock_schedule
+        SlackScheduler.send_and_delete("Test Message", "C123456", 4)
+
+        mock_send_message.assert_called_once_with("Test Message", "C123456")
+        mock_filter.assert_called_once_with(pk=4)
+        mock_schedule.reminder.delete.assert_called_once()
+
     @patch("apps.nest.schedulers.calendar_events.slack.SlackScheduler.send_message")
     @patch("apps.nest.schedulers.calendar_events.slack.update_reminder_schedule_date")
     def test_send_and_update(self, mock_update_reminder_schedule_date, mock_send_message):