Example #1
0
    def test_autowatch_reply(self, get_current):
        """Replying to a thread creates a watch."""
        get_current.return_value.domain = 'testserver'

        u = user(save=True)
        t1 = thread(save=True)
        t2 = thread(save=True)

        assert not NewPostEvent.is_notifying(u, t1)
        assert not NewPostEvent.is_notifying(u, t2)

        self.client.login(username=u.username, password='******')

        # If the poster has the forums_watch_after_reply setting set to True,
        # they will start watching threads they reply to.
        s = Setting.objects.create(user=u,
                                   name='forums_watch_after_reply',
                                   value='True')
        data = {'content': 'some content'}
        post(self.client, 'forums.reply', data, args=[t1.forum.slug, t1.pk])
        assert NewPostEvent.is_notifying(u, t1)

        # Setting forums_watch_after_reply back to False, now they shouldn't
        # start watching threads they reply to.
        s.value = 'False'
        s.save()
        post(self.client, 'forums.reply', data, args=[t2.forum.slug, t2.pk])
        assert not NewPostEvent.is_notifying(u, t2)
Example #2
0
    def test_autowatch_reply(self, get_current):
        """Replying to a thread creates a watch."""
        get_current.return_value.domain = 'testserver'

        u = user(save=True)
        t1 = thread(save=True)
        t2 = thread(save=True)

        assert not NewPostEvent.is_notifying(u, t1)
        assert not NewPostEvent.is_notifying(u, t2)

        self.client.login(username=u.username, password='******')

        # If the poster has the forums_watch_after_reply setting set to True,
        # they will start watching threads they reply to.
        s = Setting.objects.create(user=u, name='forums_watch_after_reply',
                                   value='True')
        data = {'content': 'some content'}
        post(self.client, 'forums.reply', data, args=[t1.forum.slug, t1.pk])
        assert NewPostEvent.is_notifying(u, t1)

        # Setting forums_watch_after_reply back to False, now they shouldn't
        # start watching threads they reply to.
        s.value = 'False'
        s.save()
        post(self.client, 'forums.reply', data, args=[t2.forum.slug, t2.pk])
        assert not NewPostEvent.is_notifying(u, t2)
Example #3
0
    def test_autowatch_reply(self, get_current):
        """Replying to a thread creates a watch."""
        get_current.return_value.domain = "testserver"

        u = UserFactory()
        t1 = ThreadFactory()
        t2 = ThreadFactory()

        assert not NewPostEvent.is_notifying(u, t1)
        assert not NewPostEvent.is_notifying(u, t2)

        self.client.login(username=u.username, password="******")

        # If the poster has the forums_watch_after_reply setting set to True,
        # they will start watching threads they reply to.
        s = Setting.objects.create(user=u,
                                   name="forums_watch_after_reply",
                                   value="True")
        data = {"content": "some content"}
        post(self.client, "forums.reply", data, args=[t1.forum.slug, t1.pk])
        assert NewPostEvent.is_notifying(u, t1)

        # Setting forums_watch_after_reply back to False, now they shouldn't
        # start watching threads they reply to.
        s.value = "False"
        s.save()
        post(self.client, "forums.reply", data, args=[t2.forum.slug, t2.pk])
        assert not NewPostEvent.is_notifying(u, t2)
Example #4
0
def reply(request, forum_slug, thread_id):
    """Reply to a thread."""
    forum = get_object_or_404(Forum, slug=forum_slug)
    user = request.user
    if not forum.allows_posting_by(user):
        if forum.allows_viewing_by(user):
            raise PermissionDenied
        else:
            raise Http404

    form = ReplyForm(request.POST)
    post_preview = None
    if form.is_valid():
        thread = get_object_or_404(Thread, pk=thread_id, forum=forum)

        if not thread.is_locked:
            reply_ = form.save(commit=False)
            reply_.thread = thread
            reply_.author = request.user
            if "preview" in request.POST:
                post_preview = reply_
                post_preview.author_post_count = reply_.author.post_set.count()
            elif not is_ratelimited(request, "forum-post", "15/d"):
                reply_.save()

                # Subscribe the user to the thread.
                if Setting.get_for_user(request.user, "forums_watch_after_reply"):
                    NewPostEvent.notify(request.user, thread)

                # Send notifications to thread/forum watchers.
                NewPostEvent(reply_).fire(exclude=reply_.author)

                return HttpResponseRedirect(thread.get_last_post_url())

    return posts(request, forum_slug, thread_id, form, post_preview, is_reply=True)
Example #5
0
def new_thread(request, forum_slug):
    """Start a new thread."""
    forum = get_object_or_404(Forum, slug=forum_slug)
    user = request.user
    if not forum.allows_posting_by(user):
        if forum.allows_viewing_by(user):
            raise PermissionDenied
        else:
            raise Http404

    if request.method == 'GET':
        form = NewThreadForm()
        return render(request, 'forums/new_thread.html', {
            'form': form,
            'forum': forum
        })

    form = NewThreadForm(request.POST)
    post_preview = None
    if form.is_valid():
        if 'preview' in request.POST:
            thread = Thread(creator=request.user,
                            title=form.cleaned_data['title'])
            post_preview = Post(thread=thread,
                                author=request.user,
                                content=form.cleaned_data['content'])
            post_preview.author_post_count = \
                post_preview.author.post_set.count()
        elif (_skip_post_ratelimit(request)
              or not is_ratelimited(request,
                                    increment=True,
                                    rate='5/d',
                                    ip=False,
                                    keys=user_or_ip('forum-post'))):
            thread = forum.thread_set.create(creator=request.user,
                                             title=form.cleaned_data['title'])
            thread.save()
            statsd.incr('forums.thread')
            post = thread.new_post(author=request.user,
                                   content=form.cleaned_data['content'])
            post.save()

            NewThreadEvent(post).fire(exclude=post.author)

            # Add notification automatically if needed.
            if Setting.get_for_user(request.user, 'forums_watch_new_thread'):
                NewPostEvent.notify(request.user, thread)

            url = reverse('forums.posts', args=[forum_slug, thread.id])
            return HttpResponseRedirect(urlparams(url, last=post.id))

    return render(request, 'forums/new_thread.html', {
        'form': form,
        'forum': forum,
        'post_preview': post_preview
    })
 def _toggle_watch_thread_as(self, thread, user, turn_on=True):
     """Watch a thread and return it."""
     self.client.login(username=user.username, password="******")
     watch = "yes" if turn_on else "no"
     post(self.client, "forums.watch_thread", {"watch": watch}, args=[thread.forum.slug, thread.id])
     # Watch exists or not, depending on watch.
     if turn_on:
         assert NewPostEvent.is_notifying(user, thread), "NewPostEvent should be notifying."
     else:
         assert not NewPostEvent.is_notifying(user, thread), "NewPostEvent should not be notifying."
Example #7
0
def new_thread(request, forum_slug):
    """Start a new thread."""
    forum = get_object_or_404(Forum, slug=forum_slug)
    user = request.user
    if not forum.allows_posting_by(user):
        if forum.allows_viewing_by(user):
            raise PermissionDenied
        else:
            raise Http404

    if request.method == "GET":
        form = NewThreadForm()
        return render(request, "forums/new_thread.html", {
            "form": form,
            "forum": forum
        })

    form = NewThreadForm(request.POST)
    post_preview = None
    if form.is_valid():
        if "preview" in request.POST:
            thread = Thread(creator=request.user,
                            title=form.cleaned_data["title"])
            post_preview = Post(thread=thread,
                                author=request.user,
                                content=form.cleaned_data["content"])
            post_preview.author_post_count = post_preview.author.post_set.count(
            )
        elif not is_ratelimited(request, "forum-post", "5/d"):
            thread = forum.thread_set.create(creator=request.user,
                                             title=form.cleaned_data["title"])
            thread.save()
            post = thread.new_post(author=request.user,
                                   content=form.cleaned_data["content"])
            post.save()

            NewThreadEvent(post).fire(exclude=post.author)

            # Add notification automatically if needed.
            if Setting.get_for_user(request.user, "forums_watch_new_thread"):
                NewPostEvent.notify(request.user, thread)

            url = reverse("forums.posts", args=[forum_slug, thread.id])
            return HttpResponseRedirect(urlparams(url, last=post.id))

    return render(
        request,
        "forums/new_thread.html",
        {
            "form": form,
            "forum": forum,
            "post_preview": post_preview
        },
    )
Example #8
0
 def _toggle_watch_thread_as(self, thread, user, turn_on=True):
     """Watch a thread and return it."""
     self.client.login(username=user.username, password='******')
     watch = 'yes' if turn_on else 'no'
     post(self.client, 'forums.watch_thread', {'watch': watch},
          args=[thread.forum.slug, thread.id])
     # Watch exists or not, depending on watch.
     if turn_on:
         assert NewPostEvent.is_notifying(user, thread), (
             'NewPostEvent should be notifying.')
     else:
         assert not NewPostEvent.is_notifying(user, thread), (
             'NewPostEvent should not be notifying.')
Example #9
0
 def _toggle_watch_thread_as(self, thread, user, turn_on=True):
     """Watch a thread and return it."""
     self.client.login(username=user.username, password='******')
     watch = 'yes' if turn_on else 'no'
     post(self.client, 'forums.watch_thread', {'watch': watch},
          args=[thread.forum.slug, thread.id])
     # Watch exists or not, depending on watch.
     if turn_on:
         assert NewPostEvent.is_notifying(user, thread), (
             'NewPostEvent should be notifying.')
     else:
         assert not NewPostEvent.is_notifying(user, thread), (
             'NewPostEvent should not be notifying.')
Example #10
0
def watch_thread(request, forum_slug, thread_id):
    """Watch/unwatch a thread (based on 'watch' POST param)."""
    forum = get_object_or_404(Forum, slug=forum_slug)
    if not forum.allows_viewing_by(request.user):
        raise Http404

    thread = get_object_or_404(Thread, pk=thread_id, forum=forum)

    if request.POST.get("watch") == "yes":
        NewPostEvent.notify(request.user, thread)
    else:
        NewPostEvent.stop_notifying(request.user, thread)

    return HttpResponseRedirect(reverse("forums.posts", args=[forum_slug, thread_id]))
Example #11
0
    def test_watch_thread(self):
        """Watch then unwatch a thread."""
        t = ThreadFactory()
        u = UserFactory()

        self.client.login(username=u.username, password='******')

        post(self.client, 'forums.watch_thread', {'watch': 'yes'}, args=[t.forum.slug, t.id])
        assert NewPostEvent.is_notifying(u, t)
        # NewThreadEvent is not notifying.
        assert not NewThreadEvent.is_notifying(u, t.forum)

        post(self.client, 'forums.watch_thread', {'watch': 'no'},
             args=[t.forum.slug, t.id])
        assert not NewPostEvent.is_notifying(u, t)
Example #12
0
    def test_watch_thread(self):
        """Watch then unwatch a thread."""
        t = ThreadFactory()
        u = UserFactory()

        self.client.login(username=u.username, password='******')

        post(self.client, 'forums.watch_thread', {'watch': 'yes'}, args=[t.forum.slug, t.id])
        assert NewPostEvent.is_notifying(u, t)
        # NewThreadEvent is not notifying.
        assert not NewThreadEvent.is_notifying(u, t.forum)

        post(self.client, 'forums.watch_thread', {'watch': 'no'},
             args=[t.forum.slug, t.id])
        assert not NewPostEvent.is_notifying(u, t)
Example #13
0
def new_thread(request, forum_slug):
    """Start a new thread."""
    forum = get_object_or_404(Forum, slug=forum_slug)
    user = request.user
    if not forum.allows_posting_by(user):
        if forum.allows_viewing_by(user):
            raise PermissionDenied
        else:
            raise Http404

    if request.method == 'GET':
        form = NewThreadForm()
        return render(request, 'forums/new_thread.html', {
            'form': form, 'forum': forum})

    form = NewThreadForm(request.POST)
    post_preview = None
    if form.is_valid():
        if 'preview' in request.POST:
            thread = Thread(creator=request.user,
                            title=form.cleaned_data['title'])
            post_preview = Post(thread=thread, author=request.user,
                                content=form.cleaned_data['content'])
            post_preview.author_post_count = \
                post_preview.author.post_set.count()
        elif (_skip_post_ratelimit(request) or
              not is_ratelimited(request, increment=True, rate='5/d', ip=False,
                                 keys=user_or_ip('forum-post'))):
            thread = forum.thread_set.create(creator=request.user,
                                             title=form.cleaned_data['title'])
            thread.save()
            statsd.incr('forums.thread')
            post = thread.new_post(author=request.user,
                                   content=form.cleaned_data['content'])
            post.save()

            NewThreadEvent(post).fire(exclude=post.author)

            # Add notification automatically if needed.
            if Setting.get_for_user(request.user, 'forums_watch_new_thread'):
                NewPostEvent.notify(request.user, thread)

            url = reverse('forums.posts', args=[forum_slug, thread.id])
            return HttpResponseRedirect(urlparams(url, last=post.id))

    return render(request, 'forums/new_thread.html', {
        'form': form, 'forum': forum,
        'post_preview': post_preview})
Example #14
0
def watch_thread(request, forum_slug, thread_id):
    """Watch/unwatch a thread (based on 'watch' POST param)."""
    forum = get_object_or_404(Forum, slug=forum_slug)
    if not forum.allows_viewing_by(request.user):
        raise Http404

    thread = get_object_or_404(Thread, pk=thread_id, forum=forum)

    if request.POST.get('watch') == 'yes':
        NewPostEvent.notify(request.user, thread)
        statsd.incr('forums.watches.thread')
    else:
        NewPostEvent.stop_notifying(request.user, thread)

    return HttpResponseRedirect(reverse('forums.posts',
                                        args=[forum_slug, thread_id]))
Example #15
0
def posts(request,
          forum_slug,
          thread_id,
          form=None,
          post_preview=None,
          is_reply=False):
    """View all the posts in a thread."""
    thread = get_object_or_404(Thread, pk=thread_id)
    forum = thread.forum

    if forum.slug != forum_slug and not is_reply:
        new_forum = get_object_or_404(Forum, slug=forum_slug)
        if new_forum.allows_viewing_by(request.user):
            return HttpResponseRedirect(thread.get_absolute_url())
        raise Http404  # User has no right to view destination forum.
    elif forum.slug != forum_slug:
        raise Http404

    if not forum.allows_viewing_by(request.user):
        raise Http404

    posts_ = thread.post_set.all()
    count = posts_.count()
    if count:
        last_post = posts_[count - 1]
    else:
        last_post = None
    posts_ = posts_.select_related('author', 'updated_by')
    posts_ = posts_.extra(
        select={
            'author_post_count':
            'SELECT COUNT(*) FROM forums_post WHERE '
            'forums_post.author_id = auth_user.id'
        })
    posts_ = paginate(request, posts_, constants.POSTS_PER_PAGE, count=count)

    if not form:
        form = ReplyForm()

    feed_urls = ((reverse('forums.posts.feed',
                          kwargs={
                              'forum_slug': forum_slug,
                              'thread_id': thread_id
                          }), PostsFeed().title(thread)), )

    is_watching_thread = (request.user.is_authenticated()
                          and NewPostEvent.is_notifying(request.user, thread))
    return render(
        request, 'forums/posts.html', {
            'forum': forum,
            'thread': thread,
            'posts': posts_,
            'form': form,
            'count': count,
            'last_post': last_post,
            'post_preview': post_preview,
            'is_watching_thread': is_watching_thread,
            'feeds': feed_urls,
            'forums': Forum.objects.all()
        })
Example #16
0
 def _toggle_watch_thread_as(self, thread, user, turn_on=True):
     """Watch a thread and return it."""
     self.client.login(username=user.username, password="******")
     watch = "yes" if turn_on else "no"
     post(
         self.client,
         "forums.watch_thread",
         {"watch": watch},
         args=[thread.forum.slug, thread.id],
     )
     # Watch exists or not, depending on watch.
     if turn_on:
         assert NewPostEvent.is_notifying(
             user, thread), "NewPostEvent should be notifying."
     else:
         assert not NewPostEvent.is_notifying(
             user, thread), "NewPostEvent should not be notifying."
Example #17
0
    def test_watch_thread(self):
        """Watch then unwatch a thread."""
        t = ThreadFactory()
        u = UserFactory()

        self.client.login(username=u.username, password="******")

        post(self.client,
             "forums.watch_thread", {"watch": "yes"},
             args=[t.forum.slug, t.id])
        assert NewPostEvent.is_notifying(u, t)
        # NewThreadEvent is not notifying.
        assert not NewThreadEvent.is_notifying(u, t.forum)

        post(self.client,
             "forums.watch_thread", {"watch": "no"},
             args=[t.forum.slug, t.id])
        assert not NewPostEvent.is_notifying(u, t)
    def test_autowatch_new_thread(self, get_current):
        """Creating a new thread should email responses"""
        get_current.return_value.domain = "testserver"

        f = forum(save=True)
        u = user(save=True)

        self.client.login(username=u.username, password="******")
        s = Setting.objects.create(user=u, name="forums_watch_new_thread", value="False")
        data = {"title": "a title", "content": "a post"}
        post(self.client, "forums.new_thread", data, args=[f.slug])
        t1 = Thread.objects.all().order_by("-id")[0]
        assert not NewPostEvent.is_notifying(u, t1), "NewPostEvent should not be notifying."

        s.value = "True"
        s.save()
        post(self.client, "forums.new_thread", data, args=[f.slug])
        t2 = Thread.uncached.all().order_by("-id")[0]
        assert NewPostEvent.is_notifying(u, t2), "NewPostEvent should be notifying."
Example #19
0
def reply(request, forum_slug, thread_id):
    """Reply to a thread."""
    forum = get_object_or_404(Forum, slug=forum_slug)
    user = request.user
    if not forum.allows_posting_by(user):
        if forum.allows_viewing_by(user):
            raise PermissionDenied
        else:
            raise Http404

    form = ReplyForm(request.POST)
    post_preview = None
    if form.is_valid():
        thread = get_object_or_404(Thread, pk=thread_id, forum=forum)

        if not thread.is_locked:
            reply_ = form.save(commit=False)
            reply_.thread = thread
            reply_.author = request.user
            if 'preview' in request.POST:
                post_preview = reply_
                post_preview.author_post_count = \
                    reply_.author.post_set.count()
            elif (_skip_post_ratelimit(request) or
                  not is_ratelimited(request, increment=True, rate='5/d',
                                     ip=False,
                                     keys=user_or_ip('forum-post'))):
                reply_.save()
                statsd.incr('forums.reply')

                # Subscribe the user to the thread.
                if Setting.get_for_user(request.user,
                                        'forums_watch_after_reply'):
                    NewPostEvent.notify(request.user, thread)

                # Send notifications to thread/forum watchers.
                NewPostEvent(reply_).fire(exclude=reply_.author)

                return HttpResponseRedirect(thread.get_last_post_url())

    return posts(request, forum_slug, thread_id, form, post_preview,
                 is_reply=True)
Example #20
0
    def test_autowatch_new_thread(self, get_current):
        """Creating a new thread should email responses"""
        get_current.return_value.domain = 'testserver'

        f = forum(save=True)
        u = user(save=True)

        self.client.login(username=u.username, password='******')
        s = Setting.objects.create(user=u, name='forums_watch_new_thread',
                                   value='False')
        data = {'title': 'a title', 'content': 'a post'}
        post(self.client, 'forums.new_thread', data, args=[f.slug])
        t1 = Thread.objects.all().order_by('-id')[0]
        assert not NewPostEvent.is_notifying(u, t1), (
            'NewPostEvent should not be notifying.')

        s.value = 'True'
        s.save()
        post(self.client, 'forums.new_thread', data, args=[f.slug])
        t2 = Thread.uncached.all().order_by('-id')[0]
        assert NewPostEvent.is_notifying(u, t2), (
            'NewPostEvent should be notifying.')
Example #21
0
    def test_autowatch_new_thread(self, get_current):
        """Creating a new thread should email responses"""
        get_current.return_value.domain = 'testserver'

        f = forum(save=True)
        u = user(save=True)

        self.client.login(username=u.username, password='******')
        s = Setting.objects.create(user=u, name='forums_watch_new_thread',
                                   value='False')
        data = {'title': 'a title', 'content': 'a post'}
        post(self.client, 'forums.new_thread', data, args=[f.slug])
        t1 = Thread.objects.all().order_by('-id')[0]
        assert not NewPostEvent.is_notifying(u, t1), (
            'NewPostEvent should not be notifying.')

        s.value = 'True'
        s.save()
        post(self.client, 'forums.new_thread', data, args=[f.slug])
        t2 = Thread.objects.all().order_by('-id')[0]
        assert NewPostEvent.is_notifying(u, t2), (
            'NewPostEvent should be notifying.')
Example #22
0
    def test_autowatch_new_thread(self, get_current):
        """Creating a new thread should email responses"""
        get_current.return_value.domain = "testserver"

        f = ForumFactory()
        u = UserFactory()

        self.client.login(username=u.username, password="******")
        s = Setting.objects.create(user=u,
                                   name="forums_watch_new_thread",
                                   value="False")
        data = {"title": "a title", "content": "a post"}
        post(self.client, "forums.new_thread", data, args=[f.slug])
        t1 = Thread.objects.all().order_by("-id")[0]
        assert not NewPostEvent.is_notifying(
            u, t1), "NewPostEvent should not be notifying."

        s.value = "True"
        s.save()
        post(self.client, "forums.new_thread", data, args=[f.slug])
        t2 = Thread.objects.all().order_by("-id")[0]
        assert NewPostEvent.is_notifying(
            u, t2), "NewPostEvent should be notifying."
Example #23
0
def posts(request, forum_slug, thread_id, form=None, post_preview=None,
          is_reply=False):
    """View all the posts in a thread."""
    thread = get_object_or_404(Thread, pk=thread_id)
    forum = thread.forum

    if forum.slug != forum_slug and not is_reply:
        new_forum = get_object_or_404(Forum, slug=forum_slug)
        if new_forum.allows_viewing_by(request.user):
            return HttpResponseRedirect(thread.get_absolute_url())
        raise Http404  # User has no right to view destination forum.
    elif forum.slug != forum_slug:
        raise Http404

    if not forum.allows_viewing_by(request.user):
        raise Http404

    posts_ = thread.post_set.all()
    count = posts_.count()
    if count:
        last_post = posts_[count - 1]
    else:
        last_post = None
    posts_ = posts_.select_related('author', 'updated_by')
    posts_ = posts_.extra(
        select={'author_post_count': 'SELECT COUNT(*) FROM forums_post WHERE '
                                     'forums_post.author_id = auth_user.id'})
    posts_ = paginate(request, posts_, constants.POSTS_PER_PAGE, count=count)

    if not form:
        form = ReplyForm()

    feed_urls = ((reverse('forums.posts.feed',
                          kwargs={'forum_slug': forum_slug,
                                  'thread_id': thread_id}),
                  PostsFeed().title(thread)),)

    is_watching_thread = (request.user.is_authenticated() and
                          NewPostEvent.is_notifying(request.user, thread))
    return render(request, 'forums/posts.html', {
        'forum': forum, 'thread': thread,
        'posts': posts_, 'form': form,
        'count': count,
        'last_post': last_post,
        'post_preview': post_preview,
        'is_watching_thread': is_watching_thread,
        'feeds': feed_urls,
        'forums': Forum.objects.all()})
Example #24
0
    def test_watch_forum(self):
        """Watch then unwatch a forum."""
        f = forum(save=True)
        forum_post(thread=thread(forum=f, save=True), save=True)
        u = user(save=True)

        self.client.login(username=u.username, password='******')

        post(self.client, 'forums.watch_forum', {'watch': 'yes'},
             args=[f.slug])
        assert NewThreadEvent.is_notifying(u, f)
        # NewPostEvent is not notifying.
        assert not NewPostEvent.is_notifying(u, f.last_post)

        post(self.client, 'forums.watch_forum', {'watch': 'no'},
             args=[f.slug])
        assert not NewThreadEvent.is_notifying(u, f)
Example #25
0
    def test_watch_forum(self):
        """Watch then unwatch a forum."""
        f = ForumFactory()
        PostFactory(thread__forum=f)
        u = UserFactory()

        self.client.login(username=u.username, password='******')

        post(self.client, 'forums.watch_forum', {'watch': 'yes'},
             args=[f.slug])
        assert NewThreadEvent.is_notifying(u, f)
        # NewPostEvent is not notifying.
        assert not NewPostEvent.is_notifying(u, f.last_post)

        post(self.client, 'forums.watch_forum', {'watch': 'no'},
             args=[f.slug])
        assert not NewThreadEvent.is_notifying(u, f)
Example #26
0
    def test_watch_forum(self):
        """Watch then unwatch a forum."""
        f = ForumFactory()
        PostFactory(thread__forum=f)
        u = UserFactory()

        self.client.login(username=u.username, password="******")

        post(self.client,
             "forums.watch_forum", {"watch": "yes"},
             args=[f.slug])
        assert NewThreadEvent.is_notifying(u, f)
        # NewPostEvent is not notifying.
        assert not NewPostEvent.is_notifying(u, f.last_post)

        post(self.client, "forums.watch_forum", {"watch": "no"}, args=[f.slug])
        assert not NewThreadEvent.is_notifying(u, f)
Example #27
0
    def test_watch_forum(self):
        """Watch then unwatch a forum."""
        f = ForumFactory()
        PostFactory(thread__forum=f)
        u = UserFactory()

        self.client.login(username=u.username, password='******')

        post(self.client, 'forums.watch_forum', {'watch': 'yes'},
             args=[f.slug])
        assert NewThreadEvent.is_notifying(u, f)
        # NewPostEvent is not notifying.
        assert not NewPostEvent.is_notifying(u, f.last_post)

        post(self.client, 'forums.watch_forum', {'watch': 'no'},
             args=[f.slug])
        assert not NewThreadEvent.is_notifying(u, f)
Example #28
0
    def test_watch_forum(self):
        """Watch then unwatch a forum."""
        f = forum(save=True)
        forum_post(thread=thread(forum=f, save=True), save=True)
        u = user(save=True)

        self.client.login(username=u.username, password='******')

        post(self.client,
             'forums.watch_forum', {'watch': 'yes'},
             args=[f.slug])
        assert NewThreadEvent.is_notifying(u, f)
        # NewPostEvent is not notifying.
        assert not NewPostEvent.is_notifying(u, f.last_post)

        post(self.client, 'forums.watch_forum', {'watch': 'no'}, args=[f.slug])
        assert not NewThreadEvent.is_notifying(u, f)
Example #29
0
def posts(request,
          forum_slug,
          thread_id,
          form=None,
          post_preview=None,
          is_reply=False):
    """View all the posts in a thread."""
    thread = get_object_or_404(Thread, pk=thread_id)
    forum = thread.forum

    if forum.slug != forum_slug and not is_reply:
        new_forum = get_object_or_404(Forum, slug=forum_slug)
        if new_forum.allows_viewing_by(request.user):
            return HttpResponseRedirect(thread.get_absolute_url())
        raise Http404  # User has no right to view destination forum.
    elif forum.slug != forum_slug:
        raise Http404

    if not forum.allows_viewing_by(request.user):
        raise Http404

    posts_ = thread.post_set.all()
    count = posts_.count()
    if count:
        last_post = posts_[count - 1]
    else:
        last_post = None
    posts_ = posts_.select_related("author", "updated_by")
    posts_ = posts_.extra(
        select={
            "author_post_count":
            "SELECT COUNT(*) FROM forums_post WHERE "
            "forums_post.author_id = auth_user.id"
        })
    posts_ = paginate(request, posts_, constants.POSTS_PER_PAGE, count=count)

    if not form:
        form = ReplyForm()

    feed_urls = ((
        reverse("forums.posts.feed",
                kwargs={
                    "forum_slug": forum_slug,
                    "thread_id": thread_id
                }),
        PostsFeed().title(thread),
    ), )

    is_watching_thread = request.user.is_authenticated and NewPostEvent.is_notifying(
        request.user, thread)
    return render(
        request,
        "forums/posts.html",
        {
            "forum": forum,
            "thread": thread,
            "posts": posts_,
            "form": form,
            "count": count,
            "last_post": last_post,
            "post_preview": post_preview,
            "is_watching_thread": is_watching_thread,
            "feeds": feed_urls,
            "forums": Forum.objects.all(),
        },
    )
Example #30
0
 def test_delete_removes_watches(self):
     t = thread(save=True)
     NewPostEvent.notify('*****@*****.**', t)
     assert NewPostEvent.is_notifying('*****@*****.**', t)
     t.delete()
     assert not NewPostEvent.is_notifying('*****@*****.**', t)
Example #31
0
 def test_delete_removes_watches(self):
     t = ThreadFactory()
     NewPostEvent.notify('*****@*****.**', t)
     assert NewPostEvent.is_notifying('*****@*****.**', t)
     t.delete()
     assert not NewPostEvent.is_notifying('*****@*****.**', t)
Example #32
0
 def test_delete_removes_watches(self):
     t = thread(save=True)
     NewPostEvent.notify('*****@*****.**', t)
     assert NewPostEvent.is_notifying('*****@*****.**', t)
     t.delete()
     assert not NewPostEvent.is_notifying('*****@*****.**', t)
Example #33
0
 def test_delete_removes_watches(self):
     t = ThreadFactory()
     NewPostEvent.notify('*****@*****.**', t)
     assert NewPostEvent.is_notifying('*****@*****.**', t)
     t.delete()
     assert not NewPostEvent.is_notifying('*****@*****.**', t)