untested private thread viewmodel

misago/threads/api/threadendpoints/list.py

@@ -22,6 +22,9 @@ class ThreadsList(object):
 
         return Response(self.get_response_json(request, category, threads)['THREADS'])
 
+    def get_category(self, request, pk=None):
+        raise NotImplementedError('Threads list has to implement get_category(request, pk=None)')
+
     def get_threads(self, request, category, list_type, page):
         return self.threads(request, category, list_type, page)
 

misago/threads/permissions/privatethreads.py

@@ -151,18 +151,21 @@ can_use_private_threads = return_boolean(allow_use_private_threads)
 
 
 def allow_see_private_thread(user, target):
-    can_see_unapproved = user.acl.get('can_moderate_private_threads')
-    can_see_unapproved = can_see_unapproved and target.has_reported_posts
+    if user.acl.get('can_moderate_private_threads'):
+        can_see_reported = target.has_reported_posts
+    else:
+        can_see_reported = False
+
     can_see_participating = user in [p.user for p in target.participants_list]
 
-    if not (can_see_participating or can_see_unapproved):
+    if not (can_see_participating or can_see_reported):
         raise Http404()
 can_see_private_thread = return_boolean(allow_see_private_thread)
 
 
 def allow_see_private_post(user, target):
-    can_see_unapproved = user.acl.get('can_moderate_private_threads')
-    if not (can_see_unapproved and target.thread.has_reported_posts):
+    can_see_reported = user.acl.get('can_moderate_private_threads')
+    if not (can_see_reported and target.thread.has_reported_posts):
         for participant in target.thread.participants_list:
             if participant.user == user and participant.is_removed:
                 if post.posted_on > target.last_post_on:

misago/threads/threadtypes/privatethread.py

@@ -55,12 +55,6 @@ class PrivateThread(ThreadType):
             'pk': thread.pk
         })
 
-    def get_thread_unapproved_post_url(self, thread):
-        return reverse('misago:private-thread-unapproved', kwargs={
-            'slug': thread.slug,
-            'pk': thread.pk
-        })
-
     def get_thread_api_url(self, thread):
         return reverse('misago:api:private-thread-detail', kwargs={
             'pk': thread.pk

misago/threads/urls/__init__.py

@@ -2,7 +2,9 @@ from django.conf import settings
 from django.conf.urls import url
 
 from ..views.attachment import attachment_server
-from ..views.goto import ThreadGotoPostView, ThreadGotoLastView, ThreadGotoNewView, ThreadGotoUnapprovedView
+from ..views.goto import (
+    ThreadGotoPostView, ThreadGotoLastView, ThreadGotoNewView, ThreadGotoUnapprovedView,
+    PrivateThreadGotoPostView, PrivateThreadGotoLastView, PrivateThreadGotoNewView)
 from ..views.list import ForumThreads, CategoryThreads, PrivateThreads
 from ..views.thread import Thread, PrivateThread
 
@@ -113,10 +115,9 @@ urlpatterns += goto_patterns(
 
 urlpatterns += goto_patterns(
     'private-thread',
-    post=ThreadGotoPostView,
-    last=ThreadGotoLastView,
-    new=ThreadGotoNewView,
-    unapproved=ThreadGotoUnapprovedView
+    post=PrivateThreadGotoPostView,
+    last=PrivateThreadGotoLastView,
+    new=PrivateThreadGotoNewView,
 )
 
 

misago/threads/viewmodels/thread.py

@@ -2,12 +2,15 @@ from django.shortcuts import get_object_or_404
 from django.utils.translation import gettext as _
 
 from misago.acl import add_acl
-from misago.categories.models import THREADS_ROOT_NAME, Category
+from misago.categories.models import (
+    PRIVATE_THREADS_ROOT_NAME, THREADS_ROOT_NAME, Category)
 from misago.core.shortcuts import validate_slug
 from misago.core.viewmodel import ViewModel as BaseViewModel
 from misago.readtracker.threadstracker import make_read_aware
 
 from ..models import Poll, Thread
+from ..participants import make_thread_participants_aware
+from ..permissions.privatethreads import allow_see_private_thread
 from ..permissions.threads import allow_see_thread
 from ..serializers import ThreadSerializer
 from ..subscriptions import make_subscription_aware
@@ -114,5 +117,26 @@ class ForumThread(ViewModel):
 
 
 class PrivateThread(ViewModel):
-    pass
+    def get_thread(self, request, pk, slug=None, select_for_update=False):
+        if select_for_update:
+            queryset = Thread.objects.select_for_update()
+        else:
+            queryset = Thread.objects.select_related(*BASE_RELATIONS)
+
+        thread = get_object_or_404(
+            queryset,
+            pk=pk,
+            category__tree_id=trees_map.get_tree_id_for_root(PRIVATE_THREADS_ROOT_NAME)
+        )
+
+        make_thread_participants_aware(request.user, thread)
+        allow_see_private_thread(request.user, thread)
+
+        if slug:
+            validate_slug(thread, slug)
+
+        return thread
+
+    def get_root_name(self):
+        return _("Private threads")
 

misago/threads/viewmodels/threads.py

@@ -159,9 +159,6 @@ class PrivateThreads(ViewModel):
 
         return queryset
 
-    def get_pinned_threads(self, queryset, category, threads_categories):
-        return [] # this is noop for Private Threads where its impossible to weight threads
-
     def get_remaining_threads_queryset(self, queryset, category, threads_categories):
         return queryset.filter(category__in=threads_categories)
 

misago/threads/views/goto.py

@@ -8,7 +8,7 @@ from django.views.generic import View
 from misago.conf import settings
 
 from ..permissions.threads import exclude_invisible_posts
-from ..viewmodels import ForumThread
+from ..viewmodels import ForumThread, PrivateThread
 
 
 class GotoView(View):
@@ -98,3 +98,29 @@ class ThreadGotoUnapprovedView(GotoView):
             return unapproved_post
         else:
             return posts_queryset.order_by('id').last()
+
+
+class PrivateThreadGotoPostView(GotoView):
+    thread = PrivateThread
+
+    def get_target_post(self, thread, posts_queryset, **kwargs):
+        return get_object_or_404(posts_queryset, pk=kwargs['post'])
+
+
+class PrivateThreadGotoLastView(GotoView):
+    thread = PrivateThread
+
+    def get_target_post(self, thread, posts_queryset, **kwargs):
+        return posts_queryset.order_by('id').last()
+
+
+class PrivateThreadGotoNewView(GotoView):
+    thread = PrivateThread
+    read_aware = True
+
+    def get_target_post(self, thread, posts_queryset, **kwargs):
+        if thread.is_new:
+            return posts_queryset.filter(posted_on__gt=thread.last_read_on).order_by('id').first()
+        else:
+            return posts_queryset.order_by('id').last()
+