def test_thread_read_for_guest(self): """threads are always read for guests""" threadstracker.make_read_aware(self.anon, self.thread) self.assertTrue(self.thread.is_read) threadstracker.make_read_aware(self.anon, [self.thread]) self.assertTrue(self.thread.is_read)
def __init__(self, request, pk, slug=None, read_aware=False, subscription_aware=False, poll_votes_aware=False, select_for_update=False): model = self.get_thread(request, pk, slug, select_for_update) model.path = self.get_thread_path(model.category) add_acl(request.user, model.category) add_acl(request.user, model) if read_aware: make_read_aware(request.user, model) if subscription_aware: make_subscription_aware(request.user, model) self._model = model self._category = model.category self._path = model.path try: self._poll = model.poll add_acl(request.user, self._poll) if poll_votes_aware: self._poll.make_choices_votes_aware(request.user) except Poll.DoesNotExist: self._poll = None
def test_thread_read_for_guest(self): """threads are always read for guests""" threadstracker.make_read_aware(self.anon, self.thread) self.assertTrue(self.thread.is_read) self.reply_thread() threadstracker.make_read_aware(self.anon, [self.thread]) self.assertTrue(self.thread.is_read)
def dispatch(self, request, *args, **kwargs): relations = ['forum', 'starter', 'last_poster', 'first_post'] thread = self.fetch_thread(request, select_related=relations, **kwargs) forum = thread.forum self.check_forum_permissions(request, forum) self.check_thread_permissions(request, thread) validate_slug(thread, kwargs['thread_slug']) threadstracker.make_read_aware(request.user, thread) thread_actions = self.ThreadActions(user=request.user, thread=thread) posts_actions = self.PostsActions(user=request.user, thread=thread) if request.method == 'POST': if thread_actions.query_key in request.POST: response = thread_actions.handle_post(request, thread) if response: return response if posts_actions.query_key in request.POST: queryset = self.get_posts_queryset(request.user, forum, thread) response = posts_actions.handle_post(request, queryset) if response: return response page, posts = self.get_posts(request.user, forum, thread, kwargs) make_posts_reports_aware(request.user, thread, posts) threadstracker.make_posts_read_aware(request.user, thread, posts) threadstracker.read_thread(request.user, thread, posts[-1]) try: allow_reply_thread(request.user, thread) thread_reply_message = None except PermissionDenied as e: thread_reply_message = unicode(e) return self.render(request, { 'link_name': request.resolver_match.view_name, 'links_params': { 'thread_id': thread.id, 'thread_slug': thread.slug }, 'forum': forum, 'path': get_forum_path(forum), 'thread': thread, 'thread_actions': thread_actions, 'thread_reply_message': thread_reply_message, 'posts': posts, 'posts_actions': posts_actions, 'selected_posts': posts_actions.get_selected_ids(), 'paginator': page.paginator, 'page': page, })
def dispatch(self, request, *args, **kwargs): relations = ['forum', 'starter', 'last_poster', 'first_post'] thread = self.fetch_thread(request, select_related=relations, **kwargs) forum = thread.forum self.check_forum_permissions(request, forum) self.check_thread_permissions(request, thread) validate_slug(thread, kwargs['thread_slug']) threadstracker.make_read_aware(request.user, thread) thread_actions = self.ThreadActions(user=request.user, thread=thread) posts_actions = self.PostsActions(user=request.user, thread=thread) if request.method == 'POST': if thread_actions.query_key in request.POST: response = thread_actions.handle_post(request, thread) if response: return response if posts_actions.query_key in request.POST: queryset = self.get_posts_queryset(request.user, forum, thread) response = posts_actions.handle_post(request, queryset) if response: return response page, posts = self.get_posts(request.user, forum, thread, kwargs) threadstracker.make_posts_read_aware(request.user, thread, posts) threadstracker.read_thread(request.user, thread, posts[-1]) try: allow_reply_thread(request.user, thread) thread_reply_message = None except PermissionDenied as e: thread_reply_message = unicode(e) return self.render(request, { 'link_name': thread.get_url_name(), 'links_params': { 'thread_id': thread.id, 'thread_slug': thread.slug }, 'forum': forum, 'path': get_forum_path(forum), 'thread': thread, 'thread_actions': thread_actions, 'thread_reply_message': thread_reply_message, 'posts': posts, 'posts_actions': posts_actions, 'selected_posts': posts_actions.get_selected_ids(), 'paginator': page.paginator, 'page': page, })
def new(user, thread): make_read_aware(user, thread) if thread.is_read: return last(user, thread) posts, qs = posts_queryset(user, thread) try: first_unread = qs.filter(posted_on__gt=thread.last_read_on)[:1][0] except IndexError: return last(user, thread) return get_post_link(posts, qs, thread, first_unread)
def test_read_category_prunes_threadreads(self): """read_category prunes threadreads in this category""" thread = self.post_thread(timezone.now()) threadstracker.make_read_aware(self.user, thread) threadstracker.read_thread(self.user, thread, thread.last_post) self.assertTrue(self.user.threadread_set.exists()) categoriestracker.read_category(self.user, self.category) self.assertTrue(self.user.categoryread_set.get(category=self.category)) self.assertFalse(self.user.threadread_set.exists())
def test_sync_record_for_category_threads_behind_cutoff(self): """ sync_record sets read flag on category with only thread being behind cutoff """ self.post_thread(timezone.now() - timedelta(days=180)) read_thread = self.post_thread(timezone.now()) threadstracker.make_read_aware(self.user, read_thread) threadstracker.read_thread(self.user, read_thread, read_thread.last_post) category = Category.objects.get(pk=self.category.pk) categoriestracker.make_read_aware(self.user, [category]) self.assertTrue(category.is_read)
def __init__(self, request, pk, slug=None, read_aware=False, subscription_aware=False, select_for_update=False): model = self.get_thread(request, pk, slug, select_for_update) model.path = self.get_thread_path(model.category) add_acl(request.user, model.category) add_acl(request.user, model) if read_aware: make_read_aware(request.user, model) if subscription_aware: make_subscription_aware(request.user, model) self._model = model self._category = model.category self._path = model.path
def __init__(self, request, pk, slug=None, read_aware=False, subscription_aware=False): thread = self.get_thread(request, pk, slug) thread.path = self.get_thread_path(thread.category) add_acl(request.user, thread.category) add_acl(request.user, thread) if read_aware: make_read_aware(request.user, thread) if subscription_aware: make_subscription_aware(request.user, thread) self.thread = thread self.category = thread.category self.path = thread.path
def post_read_endpoint(request, thread, post): poststracker.make_read_aware(request.user, post) if post.is_new: poststracker.save_read(request.user, post) if thread.subscription and thread.subscription.last_read_on < post.posted_on: thread.subscription.last_read_on = post.posted_on thread.subscription.save() threadstracker.make_read_aware(request.user, thread) # send signal if post read marked thread as read # used in some places, eg. syncing unread thread count if post.is_new and thread.is_read: thread_read.send(request.user, thread=thread) return Response({'thread_is_read': thread.is_read})
def __init__(self, request, category, list_type, page): self.allow_see_list(request, category, list_type) category_model = category.unwrap() base_queryset = self.get_base_queryset(request, category.categories, list_type) base_queryset = base_queryset.select_related('starter', 'last_poster') threads_categories = [category_model] + category.subcategories threads_queryset = self.get_remaining_threads_queryset( base_queryset, category_model, threads_categories) list_page = paginate(threads_queryset, page, settings.MISAGO_THREADS_PER_PAGE, settings.MISAGO_THREADS_TAIL) paginator = pagination_dict(list_page) if list_page.number > 1: threads = list(list_page.object_list) else: pinned_threads = list( self.get_pinned_threads(base_queryset, category_model, threads_categories)) threads = list(pinned_threads) + list(list_page.object_list) add_categories_to_items(category_model, category.categories, threads) add_acl(request.user, threads) make_subscription_aware(request.user, threads) if list_type in ('new', 'unread'): # we already know all threads on list are unread for thread in threads: thread.is_read = False thread.is_new = True else: threadstracker.make_read_aware(request.user, threads) self.filter_threads(request, threads) # set state on object for easy access from hooks self.category = category self.threads = threads self.list_type = list_type self.paginator = paginator
def test_thread_read(self): """thread read flag is set for user, then its set as unread by reply""" self.reply_thread() add_acl(self.user, self.categories) threadstracker.make_read_aware(self.user, self.thread) self.assertFalse(self.thread.is_read) threadstracker.read_thread(self.user, self.thread, self.post) threadstracker.make_read_aware(self.user, self.thread) self.assertTrue(self.thread.is_read) categoriestracker.make_read_aware(self.user, self.categories) self.assertTrue(self.category.is_read) self.thread.last_post_on = timezone.now() self.thread.save() self.category.synchronize() self.category.save() self.reply_thread() threadstracker.make_read_aware(self.user, self.thread) self.assertFalse(self.thread.is_read) categoriestracker.make_read_aware(self.user, self.categories) self.assertFalse(self.category.is_read) posts = [post for post in self.thread.post_set.order_by('id')] threadstracker.make_posts_read_aware(self.user, self.thread, posts) for post in posts[:-1]: self.assertTrue(post.is_read) self.assertFalse(posts[-1].is_read)
def _test_thread_read(self): """thread read flag is set for user, then its set as unread by reply""" self.reply_thread(self.thread) add_acl(self.user, self.categories) threadstracker.make_read_aware(self.user, self.thread) self.assertFalse(self.thread.is_read) threadstracker.read_thread(self.user, self.thread, self.post) threadstracker.make_read_aware(self.user, self.thread) self.assertTrue(self.thread.is_read) categoriestracker.make_read_aware(self.user, self.categories) self.assertTrue(self.category.is_read) self.thread.last_post_on = timezone.now() self.thread.save() self.category.synchronize() self.category.save() self.reply_thread() threadstracker.make_read_aware(self.user, self.thread) self.assertFalse(self.thread.is_read) categoriestracker.make_read_aware(self.user, self.categories) self.assertFalse(self.category.is_read) posts = [post for post in self.thread.post_set.order_by('id')] threadstracker.make_posts_read_aware(self.user, self.thread, posts) for post in posts[:-1]: self.assertTrue(post.is_read) self.assertFalse(posts[-1].is_read)
def dispatch(self, request, *args, **kwargs): relations = ['forum', 'starter', 'last_poster', 'first_post'] thread = self.fetch_thread(request, select_related=relations, **kwargs) forum = thread.forum self.check_forum_permissions(request, forum) self.check_thread_permissions(request, thread) threadstracker.make_read_aware(request.user, thread) page, posts = self.get_posts(request.user, forum, thread, kwargs) threadstracker.make_posts_read_aware(thread, posts) threadstracker.read_thread(request.user, thread, posts[-1]) return self.render(request, { 'forum': forum, 'path': get_forum_path(forum), 'thread': thread, 'posts': posts, 'page': page, 'paginator': page.paginator, })
def dispatch(self, request, *args, **kwargs): relations = ['forum', 'starter', 'last_poster', 'first_post'] thread = self.fetch_thread(request, select_related=relations, **kwargs) forum = thread.forum self.check_forum_permissions(request, forum) self.check_thread_permissions(request, thread) threadstracker.make_read_aware(request.user, thread) page, posts = self.get_posts(request.user, forum, thread, kwargs) threadstracker.make_posts_read_aware(request.user, thread, posts) threadstracker.read_thread(request.user, thread, posts[-1]) return self.render(request, { 'forum': forum, 'path': get_forum_path(forum), 'thread': thread, 'posts': posts, 'page': page, 'paginator': page.paginator, })
def __init__(self, request, pk, slug=None, read_aware=False, subscription_aware=False, poll_votes_aware=False, select_for_update=False): model = self.get_thread(request, pk, slug, select_for_update) model.path = self.get_thread_path(model.category) add_acl(request.user, model.category) add_acl(request.user, model) if read_aware: make_read_aware(request.user, model) if subscription_aware: make_subscription_aware(request.user, model) self._model = model try: self._poll = model.poll add_acl(request.user, self._poll) if poll_votes_aware: self._poll.make_choices_votes_aware(request.user) except Poll.DoesNotExist: self._poll = None
def test_thread_read_category_cutoff(self): """thread read is handled when category cutoff is present""" self.reply_thread() add_acl(self.user, self.categories) threadstracker.make_read_aware(self.user, self.thread) self.assertFalse(self.thread.is_read) categoriestracker.read_category(self.user, self.category) threadstracker.make_read_aware(self.user, self.thread) self.assertTrue(self.thread.is_read) categoriestracker.make_read_aware(self.user, self.categories) self.assertTrue(self.category.is_read) posts = list(self.thread.post_set.order_by('id')) threadstracker.make_posts_read_aware(self.user, self.thread, posts) for post in posts: self.assertTrue(post.is_read) # post reply self.reply_thread() # test if only last post is unread posts = list(self.thread.post_set.order_by('id')) threadstracker.make_read_aware(self.user, self.thread) threadstracker.make_posts_read_aware(self.user, self.thread, posts) for post in posts[:-1]: self.assertTrue(post.is_read) self.assertTrue(posts[-1].is_new) # last post read will change readstate of categories threadstracker.make_read_aware(self.user, self.thread) threadstracker.read_thread(self.user, self.thread, posts[-1]) categoriestracker.make_read_aware(self.user, self.categories) self.assertTrue(self.category.is_read)
def make_threads_read_aware(self, threads): threadstracker.make_read_aware(self.user, threads)
def test_thread_replied_unread_for_user(self): """replied thread is unread for user""" self.reply_thread() threadstracker.make_read_aware(self.user, self.thread) self.assertFalse(self.thread.is_read)
def test_thread_read_for_user(self): """thread is read for user""" threadstracker.make_read_aware(self.user, self.thread) self.assertTrue(self.thread.is_read)
def test_thread_replied_unread_for_user(self): """replied thread is unread for user""" self.reply_thread(self.thread) threadstracker.make_read_aware(self.user, self.thread) self.assertFalse(self.thread.is_read)