display of deleted and new threads seems to work correctly

3 files changed, 109 insertions, 21 deletions

diff --git a/group_messaging/models.py b/group_messaging/models.py
index 87f3005e..f0557a9d 100644
--- a/group_messaging/models.py
+++ b/group_messaging/models.py
@@ -99,21 +99,37 @@ class MessageMemo(models.Model):
 class MessageManager(models.Manager):
     """model manager for the :class:`Message`"""
 
-    def get_threads_for_user(self, user, deleted=False):
-        user_groups = user.groups.all()
+    def get_threads(self, recipient=None, sender=None, deleted=False):
+        user_groups = recipient.groups.all()
         user_thread_filter = models.Q(
                 root=None,
                 message_type=Message.STORED,
                 recipients__in=user_groups
             )
-        deleted_filter = models.Q(
+
+        filter = user_thread_filter
+        if sender:
+            filter = filter & models.Q(sender=sender)
+
+        if deleted:
+            deleted_filter = models.Q(
                 memos__status=MessageMemo.ARCHIVED,
-                memos__user=user
+                memos__user=recipient
             )
-        if deleted:
-            return self.filter(user_thread_filter & deleted_filter)
+            return self.filter(filter & deleted_filter)
         else:
-            return self.filter(user_thread_filter & ~deleted_filter)
+            #rather a tricky query (may need to change the idea to get rid of this)
+            #select threads that have a memo for the user, but the memo is not ARCHIVED
+            #in addition, select threads that have zero memos for the user
+            marked_as_non_deleted_filter = models.Q(
+                                            memos__status=MessageMemo.SEEN,
+                                            memos__user=recipient
+                                        )
+            #part1 - marked as non-archived
+            part1 = self.filter(filter & marked_as_non_deleted_filter)
+            #part2 - messages for the user without an attached memo
+            part2 = self.filter(filter & ~models.Q(memos__user=recipient))
+            return (part1 | part2).distinct()
 
     def create(self, **kwargs):
         """creates a message"""
diff --git a/group_messaging/tests.py b/group_messaging/tests.py
index 93b6b22f..d17c0ca5 100644
--- a/group_messaging/tests.py
+++ b/group_messaging/tests.py
@@ -41,6 +41,32 @@ class ModelTests(TestCase):
         group = get_personal_group(user)
         return self.create_thread([group])
 
+
+    def get_view_context(self, view_class, data=None, user=None, method='GET'):
+        spec = ['REQUEST', 'user']
+        assert(method in ('GET', 'POST'))
+        spec.append(method)
+        request = Mock(spec=spec)
+        request.REQUEST = data
+        setattr(request, method, data)
+        request.user = user
+        return view_class().get_context(request)
+
+    def setup_three_message_thread(self):
+        """talk in this order: sender, recipient, sender"""
+        root_message = self.create_thread_for_user(self.recipient)
+        response = Message.objects.create_response(
+                                        sender=self.recipient,
+                                        text='some response',
+                                        parent=root_message
+                                    )
+        response2 = Message.objects.create_response(
+                                        sender=self.sender,
+                                        text='some response2',
+                                        parent=response
+                                    )
+        return root_message, response, response2
+
     def test_create_thread_for_user(self):
         """the basic create thread with one recipient
         tests that the recipient is there"""
@@ -102,11 +128,11 @@ class ModelTests(TestCase):
         expected_recipients = set([sender_group, recipient_group])
         self.assertEqual(recipients, expected_recipients)
 
-    def test_get_threads_for_user(self):
+    def test_get_threads(self):
         root_message = self.create_thread_for_user(self.recipient)
-        threads = set(Message.objects.get_threads_for_user(self.sender))
+        threads = set(Message.objects.get_threads(recipient=self.sender))
         self.assertEqual(threads, set([]))
-        threads = set(Message.objects.get_threads_for_user(self.recipient))
+        threads = set(Message.objects.get_threads(recipient=self.recipient))
         self.assertEqual(threads, set([root_message]))
 
         response = Message.objects.create_response(
@@ -114,9 +140,9 @@ class ModelTests(TestCase):
                                         text='some response',
                                         parent=root_message
                                     )
-        threads = set(Message.objects.get_threads_for_user(self.sender))
+        threads = set(Message.objects.get_threads(recipient=self.sender))
         self.assertEqual(threads, set([root_message]))
-        threads = set(Message.objects.get_threads_for_user(self.recipient))
+        threads = set(Message.objects.get_threads(recipient=self.recipient))
         self.assertEqual(threads, set([root_message]))
 
     def test_answer_to_deleted_thread_undeletes_thread(self):
@@ -139,12 +165,51 @@ class ModelTests(TestCase):
                                         parent=response
                                     )
 
-        view = ThreadsList()
-        request = Mock(spec=('REQUEST', 'user'))
-        request.REQUEST = {'sender_id': '-1'}
-        request.user = self.recipient
-        context = view.get_context(request)
+        context = self.get_view_context(
+                                ThreadsList,
+                                data={'sender_id': '-1'},
+                                user=self.recipient
+                            )
+
         self.assertEqual(len(context['threads']), 1)
         thread_id = context['threads'][0].id
         thread_data = context['threads_data'][thread_id]
         self.assertEqual(thread_data['status'], 'new')
+
+    def test_deleting_thread_is_user_specific(self):
+        """when one user deletes thread, that same thread
+        should not end up deleted by another user
+        """
+        root, response, response2 = self.setup_three_message_thread()
+
+        threads = Message.objects.get_threads(recipient=self.sender)
+        self.assertEquals(threads.count(), 1)
+        threads = Message.objects.get_threads(recipient=self.recipient)
+        self.assertEquals(threads.count(), 1)
+
+        memo1, created = MessageMemo.objects.get_or_create(
+                                        message=root,
+                                        user=self.recipient,
+                                        status=MessageMemo.ARCHIVED
+                                    )
+
+        threads = Message.objects.get_threads(recipient=self.sender)
+        self.assertEquals(threads.count(), 1)
+        threads = Message.objects.get_threads(recipient=self.recipient)
+        self.assertEquals(threads.count(), 0)
+        threads = Message.objects.get_threads(
+                                recipient=self.recipient, deleted=True
+                            )
+        self.assertEquals(threads.count(), 1)
+
+    def test_user_specific_inboxes(self):
+        self.create_thread_for_user(self.recipient)
+
+        threads = Message.objects.get_threads(
+                        recipient=self.recipient, sender=self.sender
+                    )
+        self.assertEqual(threads.count(), 1)
+        threads = Message.objects.get_threads(
+                        recipient=self.sender, sender=self.recipient
+                    )
+        self.assertEqual(threads.count(), 0)
diff --git a/group_messaging/views.py b/group_messaging/views.py
index ef95e1d5..e503c741 100644
--- a/group_messaging/views.py
+++ b/group_messaging/views.py
@@ -151,11 +151,18 @@ class ThreadsList(InboxView):
         #get threads and the last visit time
         sender_id = IntegerField().clean(request.REQUEST.get('sender_id', '-1'))
         if sender_id == -2:
-            threads = Message.objects.get_threads_for_user(request.user, deleted=True)
+            threads = Message.objects.get_threads(
+                                            recipient=request.user,
+                                            deleted=True
+                                        )
+        elif sender_id == -1:
+            threads = Message.objects.get_threads(recipient=request.user)
         else:
-            threads = Message.objects.get_threads_for_user(request.user)
-            if sender_id != -1:
-                threads = threads.filter(sender__id=sender_id)
+            sender = User.objects.get(id=sender_id)
+            threads = Message.objects.get_threads(
+                                            recipient=request.user,
+                                            sender=sender
+                                        )
 
         #for each thread we need to know if there is something
         #unread for the user - to mark "new" threads as bold