Refactored websockets notifications and updating threads when updating posts

boards/models/post.py

@@ -20,11 +20,6 b' from boards.models.user import Notificat'
 import boards.models.thread
 
 
-WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
-WS_NOTIFICATION_TYPE = 'notification_type'
-
-WS_CHANNEL_THREAD = "thread:"
-
 APP_LABEL_BOARDS = 'boards'
 
 POSTS_PER_DAY_RANGE = 7
@@ -195,15 +190,11 b' class Post(models.Model, Viewable):'
         the server from recalculating the map on every post show.
         """
 
-        post_urls = [REFMAP_STR.format(
-            refpost.get_url(), refpost.id) for refpost in self.referenced_posts.all()]
+        post_urls = [REFMAP_STR.format(refpost.get_url(), refpost.id)
+                     for refpost in self.referenced_posts.all()]
 
         self.refmap = ', '.join(post_urls)
 
-    # TODO Is this still needed?
-    def get_sorted_referenced_posts(self):
-        return self.refmap
-
     def is_referenced(self) -> bool:
         return self.refmap and len(self.refmap) > 0
 
@@ -240,9 +231,6 b' class Post(models.Model, Viewable):'
 
         return self.threads
 
-    def get_referenced_posts(self) -> list:
-        return self.referenced_posts.only('id', 'threads')
-
     def get_view(self, moderator=False, need_open_link=False,
                  truncated=False, *args, **kwargs) -> str:
         """
@@ -327,7 +315,7 b' class Post(models.Model, Viewable):'
                     self.get_thread().bump_time)
             return post_json
 
-    def send_to_websocket(self, request, recursive=True):
+    def notify_clients(self, request, recursive=True):
         """
         Sends post HTML data to the thread web socket.
         """
@@ -335,22 +323,11 b' class Post(models.Model, Viewable):'
         if not settings.WEBSOCKETS_ENABLED:
             return
 
-        client = Client()
-
-        logger = logging.getLogger('boards.post.websocket')
-
         thread_ids = list()
         for thread in self.get_threads().all():
             thread_ids.append(thread.id)
 
-            channel_name = WS_CHANNEL_THREAD + str(thread.get_opening_post_id())
-            client.publish(channel_name, {
-                WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
-            })
-            client.send()
-
-            logger.info('Sent notification from post #{} to channel {}'.format(
-                self.id, channel_name))
+            thread.notify_clients(request)
 
         if recursive:
             for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
@@ -362,7 +339,7 b' class Post(models.Model, Viewable):'
                     if ref_post.get_threads().exclude(id__in=thread_ids).exists():
                         # If post is in this thread, its thread was already notified.
                         # Otherwise, notify its thread separately.
-                        ref_post.send_to_websocket(request, recursive=False)
+                        ref_post.notify_clients(request, recursive=False)
                 except ObjectDoesNotExist:
                     pass
 
@@ -370,6 +347,13 b' class Post(models.Model, Viewable):'
              update_fields=None):
         self._text_rendered = Parser().parse(self.get_raw_text())
 
+        if self.id:
+            for thread in self.get_threads().all():
+                thread.update_bump_status()
+                thread.last_edit_time = self.last_edit_time
+
+                thread.save(update_fields=['last_edit_time', 'bumpable'])
+
         super().save(force_insert, force_update, using, update_fields)
 
     def get_text(self) -> str:
@@ -409,31 +393,22 b' class Post(models.Model, Viewable):'
                 referenced_post.last_edit_time = self.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
-
-                referenced_threads = referenced_post.get_threads().all()
-                for thread in referenced_threads:
-                    if thread.can_bump():
-                        thread.update_bump_status()
-
-                    thread.last_edit_time = self.pub_time
-                    thread.save(update_fields=['last_edit_time', 'bumpable'])
             except ObjectDoesNotExist:
                 pass
 
-    def connect_threads(self, threads):
+    def connect_threads(self, opening_posts):
         """
         If the referenced post is an OP in another thread,
         make this post multi-thread.
         """
 
-        for referenced_post in threads:
-            if referenced_post.is_opening():
-                referenced_threads = referenced_post.get_threads().all()
-                for thread in referenced_threads:
-                    if thread.can_bump():
-                        thread.update_bump_status()
+        for opening_post in opening_posts:
+            threads = opening_post.get_threads().all()
+            for thread in threads:
+                if thread.can_bump():
+                    thread.update_bump_status()
 
-                    thread.last_edit_time = self.pub_time
+                    thread.last_edit_time = self.last_edit_time
                     thread.save(update_fields=['last_edit_time', 'bumpable'])
 
                     self.threads.add(thread)

boards/models/thread.py

@@ -1,4 +1,5 b''
 import logging
+from adjacent import Client
 
 from django.db.models import Count, Sum
 from django.utils import timezone
@@ -17,6 +18,12 b' from boards.models.tag import Tag'
 logger = logging.getLogger(__name__)
 
 
+WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
+WS_NOTIFICATION_TYPE = 'notification_type'
+
+WS_CHANNEL_THREAD = "thread:"
+
+
 class ThreadManager(models.Manager):
     def process_oldest_threads(self):
         """
@@ -199,3 +206,15 b' class Thread(models.Model):'
         self.post_set.update(last_edit_time=self.last_edit_time)
         for post in self.post_set.all():
             post.threads.update(last_edit_time=self.last_edit_time)
+
+    def notify_clients(self, request):
+        if not settings.WEBSOCKETS_ENABLED:
+            return
+
+        client = Client()
+
+        channel_name = WS_CHANNEL_THREAD + str(self.get_opening_post_id())
+        client.publish(channel_name, {
+            WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
+            })
+        client.send()
  No newline at end of file

boards/tests/test_api.py

@@ -14,11 +14,14 b' class ApiTest(TestCase):'
         opening_post = Post.objects.create_post(title='title', text='text',
                                                 tags=[tag])
 
-        last_edit_time = datetime_to_epoch(opening_post.last_edit_time)
+        last_edit_time = str(opening_post.last_edit_time)
 
+        req = MockRequest()
+        req.GET['thread'] = opening_post.id
+        req.GET['last_update'] = last_edit_time
+        req.GET['last_post'] = opening_post.id
         # Check the exact timestamp post was added
-        empty_response = api.api_get_threaddiff(
-            MockRequest(), str(opening_post.get_thread().id), str(last_edit_time))
+        empty_response = api.api_get_threaddiff(req)
         diff = simplejson.loads(empty_response.content)
         self.assertEqual(0, len(diff['added']),
                          'There must be no added posts in the diff.')
@@ -29,18 +32,23 b' class ApiTest(TestCase):'
                                          text='[post]%d[/post]\ntext' % opening_post.id,
                                          thread=opening_post.get_thread())
 
+        req = MockRequest()
+        req.GET['thread'] = opening_post.id
+        req.GET['last_update'] = last_edit_time
+        req.GET['last_post'] = opening_post.id
         # Check the timestamp before post was added
-        response = api.api_get_threaddiff(
-            MockRequest(), str(opening_post.get_thread().id), str(last_edit_time))
+        response = api.api_get_threaddiff(req)
         diff = simplejson.loads(response.content)
         self.assertEqual(1, len(diff['added']),
                          'There must be 1 added posts in the diff.')
         self.assertEqual(1, len(diff['updated']),
                          'There must be 1 updated posts in the diff.')
 
-        empty_response = api.api_get_threaddiff(MockRequest(),
-                                            str(opening_post.get_thread().id),
-                                            str(datetime_to_epoch(reply.last_edit_time)))
+        req = MockRequest()
+        req.GET['thread'] = opening_post.id
+        req.GET['last_update'] = str(reply.last_edit_time)
+        req.GET['last_post'] = reply.id
+        empty_response = api.api_get_threaddiff(req)
         diff = simplejson.loads(empty_response.content)
         self.assertEqual(0, len(diff['added']),
                          'There must be no added posts in the diff.')

boards/tests/test_pages.py

@@ -7,7 +7,7 b" NEW_THREAD_PAGE = '/'"
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
-HTTP_CODE_REDIRECT = 301
+HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
@@ -45,7 +45,7 b' class PagesTest(TestCase):'
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             thread=Post.objects.all()[0]
-                                            .get_thread())
+                                            .get_thread()).id
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(HTTP_CODE_REDIRECT, response_not_existing.status_code,

boards/tests/test_views.py

@@ -10,6 +10,7 b' HTTP_CODE_OK = 200'
 
 EXCLUDED_VIEWS = {
         'banned',
+        'get_thread_diff',
 }
 
 

boards/views/all_threads.py

@@ -133,7 +133,7 b' class AllThreadsView(PostMixin, BaseBoar'
 
         # This is required to update the threads to which posts we have replied
         # when creating this one
-        post.send_to_websocket(request)
+        post.notify_clients(request)
 
         if html_response:
             return redirect(post.get_url())

boards/views/thread/thread.py

@@ -106,7 +106,7 b' class ThreadView(BaseBoardView, PostMixi'
 
         post = Post.objects.create_post(title=title, text=text, image=image,
                                         thread=post_thread, ip=ip, threads=threads)
-        post.send_to_websocket(request)
+        post.notify_clients(request)
 
         if html_response:
             if opening_post: