Python NewPostEvent.is_notifying方法代码示例

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
    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='testpass')

        # 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)

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
 def _toggle_watch_thread_as(self, thread, user, turn_on=True):
     """Watch a thread and return it."""
     self.client.login(username=user.username, password='testpass')
     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.')

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
    def test_watch_thread(self):
        """Watch then unwatch a thread."""
        self.client.login(username='rrosario', password='testpass')
        user = User.objects.get(username='rrosario')

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

        post(self.client, 'forums.watch_thread', {'watch': 'no'},
             args=[t.forum.slug, t.id])
        assert not NewPostEvent.is_notifying(user, t)

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
def posts(request, forum_slug, thread_id, form=None, reply_preview=None):
    """View all the posts in a thread."""
    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)

    posts_ = thread.post_set.all()
    count = posts_.count()
    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 jingo.render(request, 'forums/posts.html',
                        {'forum': forum, 'thread': thread,
                         'posts': posts_, 'form': form,
                         'reply_preview': reply_preview,
                         'is_watching_thread': is_watching_thread,
                         'feeds': feed_urls,
                         'forums': Forum.objects.all()})

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
def posts(request, forum_slug, thread_id, form=None, reply_preview=None):
    """View all the posts in a thread."""
    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)

    posts_ = paginate(request, thread.post_set.all(),
                      constants.POSTS_PER_PAGE)

    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 jingo.render(request, 'forums/posts.html',
                        {'forum': forum, 'thread': thread,
                         'posts': posts_, 'form': form,
                         'reply_preview': reply_preview,
                         'is_watching_thread': is_watching_thread,
                         'feeds': feed_urls,
                         'forums': Forum.objects.all()})

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
    def test_watch_thread(self):
        """Watch then unwatch a thread."""
        t = thread(save=True)
        u = user(save=True)

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

        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)

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
    def test_autowatch_reply(self, get_current):
        get_current.return_value.domain = 'testserver'

        user = User.objects.get(username='timw')
        t1, t2 = Thread.objects.filter(is_locked=False)[0:2]
        assert not NewPostEvent.is_notifying(user, t1)
        assert not NewPostEvent.is_notifying(user, t2)

        self.client.login(username='timw', password='testpass')
        s = Setting.objects.create(user=user, 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(user, t1)

        s.value = 'False'
        s.save()
        post(self.client, 'forums.reply', data, args=[t2.forum.slug, t2.pk])
        assert not NewPostEvent.is_notifying(user, t2)

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
    def test_autowatch_new_thread(self, get_current):
        """Creating a new thread should email responses"""
        get_current.return_value.domain = 'testserver'

        eq_(0, len(mail.outbox))
        f = Forum.objects.get(pk=1)
        self.client.login(username='jsocol', password='testpass')
        user = User.objects.get(username='jsocol')
        s = Setting.objects.create(user=user, 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(user, 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(user, t2), (
            'NewPostEvent should be notifying.')

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
    def test_watch_forum(self):
        """Watch then unwatch a forum."""
        self.client.login(username='rrosario', password='testpass')
        user = User.objects.get(username='rrosario')

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

        post(self.client, 'forums.watch_forum', {'watch': 'no'},
             args=[f.slug])
        assert not NewThreadEvent.is_notifying(user, f)

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
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 jingo.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()})

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
 def _toggle_watch_forum_as(self, username, turn_on=True, forum_id=1):
     """Watch a forum and return it."""
     forum = Forum.objects.get(pk=forum_id)
     self.client.login(username=username, password='testpass')
     user = User.objects.get(username=username)
     watch = 'yes' if turn_on else 'no'
     post(self.client, 'forums.watch_forum', {'watch': watch},
          args=[forum.slug])
     # Watch exists or not, depending on watch.
     if turn_on:
         assert NewThreadEvent.is_notifying(user, forum), (
                'NewThreadEvent should be notifying.')
     else:
         assert not NewPostEvent.is_notifying(user, forum), (
                'NewThreadEvent should not be notifying.')
     return forum

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
    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='testpass')

        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)

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
 def test_delete_removes_watches(self):
     t = Thread.objects.get(pk=1)
     NewPostEvent.notify('[email protected]', t)
     assert NewPostEvent.is_notifying('[email protected]', t)
     t.delete()
     assert not NewPostEvent.is_notifying('[email protected]', t)

# 需要导入模块: from forums.events import NewPostEvent [as 别名]
# 或者: from forums.events.NewPostEvent import is_notifying [as 别名]
 def test_delete_removes_watches(self):
     t = thread(save=True)
     NewPostEvent.notify('[email protected]', t)
     assert NewPostEvent.is_notifying('[email protected]', t)
     t.delete()
     assert not NewPostEvent.is_notifying('[email protected]', t)