def post_read_endpoint(request, thread, post):
make_posts_read_aware(request.user, thread, [post])
if not post.is_read:
read_thread(request.user, thread, post)
if thread.subscription:
thread.subscription.last_read_on = post.posted_on
return Response({'detail': 'ok'})
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 __init__(self, request, thread, page):
try:
thread_model = thread.unwrap()
except AttributeError:
thread_model = thread
posts_queryset = self.get_queryset(request, thread_model)
list_page = paginate(posts_queryset, page,
settings.MISAGO_POSTS_PER_PAGE,
settings.MISAGO_POSTS_TAIL)
paginator = pagination_dict(list_page, include_page_range=False)
posts = list(list_page.object_list)
posters = []
for post in posts:
post.category = thread.category
post.thread = thread_model
if post.poster:
posters.append(post.poster)
add_acl(request.user, posts)
make_posts_read_aware(request.user, thread_model, posts)
make_users_status_aware(request.user, posters)
if thread.category.acl['can_see_posts_likes']:
add_likes_to_posts(request.user, posts)
self._user = request.user
self.posts = posts
self.paginator = paginator
def __init__(self, request, thread, page):
try:
thread_model = thread.unwrap()
except AttributeError:
thread_model = thread
posts_queryset = self.get_queryset(request, thread_model)
list_page = paginate(
posts_queryset, page, settings.MISAGO_POSTS_PER_PAGE, settings.MISAGO_POSTS_TAIL)
paginator = pagination_dict(list_page, include_page_range=False)
posts = list(list_page.object_list)
posters = []
for post in posts:
post.category = thread.category
post.thread = thread_model
if post.poster:
posters.append(post.poster)
add_acl(request.user, posts)
make_posts_read_aware(request.user, thread_model, posts)
make_users_status_aware(request.user, posters)
if thread.category.acl['can_see_posts_likes']:
add_likes_to_posts(request.user, posts)
self._user = request.user
self.posts = posts
self.paginator = paginator
def __init__(self, request, thread, page):
posts_queryset = self.get_queryset(request, thread.model)
list_page = paginate(posts_queryset, page,
settings.MISAGO_POSTS_PER_PAGE,
settings.MISAGO_POSTS_TAIL)
paginator = pagination_dict(list_page, include_page_range=False)
posts = list(list_page.object_list)
posters = []
for post in posts:
post.category = thread.category
post.thread = thread.model
if post.poster:
posters.append(post.poster)
add_acl(request.user, posts)
make_posts_read_aware(request.user, thread.model, posts)
make_users_status_aware(request.user, posters)
self.posts = posts
self.paginator = paginator
def __init__(self, request, thread, page):
posts_queryset = self.get_queryset(request, thread.model)
list_page = paginate(posts_queryset, page, settings.MISAGO_POSTS_PER_PAGE, settings.MISAGO_POSTS_TAIL)
paginator = pagination_dict(list_page, include_page_range=False)
posts = list(list_page.object_list)
posters = []
for post in posts:
post.category = thread.category
post.thread = thread.model
if post.poster:
posters.append(post.poster)
add_acl(request.user, posts)
make_posts_read_aware(request.user, thread.model, posts)
make_users_status_aware(request.user, posters)
self._user = request.user
self.posts = posts
self.paginator = paginator
def post_read_endpoint(request, thread, post):
make_posts_read_aware(request.user, thread, [post])
if not post.is_read:
read_thread(request.user, thread, post)
if thread.subscription:
thread.subscription.last_read_on = post.posted_on
return Response({'thread_is_read': thread.last_post_on <= post.posted_on})
return Response({'thread_is_read': True})
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 __init__(self, request, thread, page):
try:
thread_model = thread.unwrap()
except AttributeError:
thread_model = thread
posts_queryset = self.get_posts_queryset(request, thread_model)
posts_limit = settings.MISAGO_POSTS_PER_PAGE
posts_orphans = settings.MISAGO_POSTS_TAIL
list_page = paginate(posts_queryset,
page,
posts_limit,
posts_orphans,
paginator=PostsPaginator)
paginator = pagination_dict(list_page)
posts = list(list_page.object_list)
posters = []
for post in posts:
post.category = thread.category
post.thread = thread_model
if post.poster:
posters.append(post.poster)
make_users_status_aware(request.user, posters)
if thread.category.acl['can_see_posts_likes']:
add_likes_to_posts(request.user, posts)
# add events to posts
if thread_model.has_events:
first_post = None
if list_page.has_previous():
first_post = posts[0]
last_post = None
if list_page.has_next():
last_post = posts[-1]
events_limit = settings.MISAGO_EVENTS_PER_PAGE
posts += self.get_events_queryset(request, thread_model,
events_limit, first_post,
last_post)
# sort both by pk
posts.sort(key=lambda p: p.pk)
# make posts and events ACL and reads aware
add_acl(request.user, posts)
make_posts_read_aware(request.user, thread_model, posts)
self._user = request.user
self.posts = posts
self.paginator = paginator
def post_read_endpoint(request, thread, post):
make_posts_read_aware(request.user, thread, [post])
if not post.is_read:
read_thread(request.user, thread, post)
if thread.subscription and thread.subscription.last_read_on < post.posted_on:
thread.subscription.last_read_on = post.posted_on
thread.subscription.save()
return Response(
{'thread_is_read': thread.last_post_on <= post.posted_on})
return Response({'thread_is_read': True})
def __init__(self, request, thread, page):
try:
thread_model = thread.unwrap()
except AttributeError:
thread_model = thread
posts_queryset = self.get_posts_queryset(request, thread_model)
posts_limit = settings.MISAGO_POSTS_PER_PAGE
posts_orphans = settings.MISAGO_POSTS_TAIL
list_page = paginate(
posts_queryset, page, posts_limit, posts_orphans, paginator=PostsPaginator
)
paginator = pagination_dict(list_page)
posts = list(list_page.object_list)
posters = []
for post in posts:
post.category = thread.category
post.thread = thread_model
if post.poster:
posters.append(post.poster)
make_users_status_aware(request.user, posters)
if thread.category.acl['can_see_posts_likes']:
add_likes_to_posts(request.user, posts)
# add events to posts
if thread_model.has_events:
first_post = None
if list_page.has_previous():
first_post = posts[0]
last_post = None
if list_page.has_next():
last_post = posts[-1]
events_limit = settings.MISAGO_EVENTS_PER_PAGE
posts += self.get_events_queryset(
request, thread_model, events_limit, first_post, last_post
)
# sort both by pk
posts.sort(key=lambda p: p.pk)
# make posts and events ACL and reads aware
add_acl(request.user, posts)
make_posts_read_aware(request.user, thread_model, posts)
self._user = request.user
self.posts = posts
self.paginator = paginator
def __init__(self, request, profile, page=0):
root_category = ThreadsRootCategory(request)
threads_categories = [root_category.unwrap()
] + root_category.subcategories
threads_queryset = self.get_threads_queryset(request,
threads_categories,
profile)
posts_queryset = self.get_posts_queryset(
request.user, profile,
threads_queryset).filter(is_hidden=False,
is_unapproved=False).order_by('-pk')
list_page = paginate(posts_queryset, page,
settings.MISAGO_POSTS_PER_PAGE,
settings.MISAGO_POSTS_TAIL)
paginator = pagination_dict(list_page, include_page_range=False)
posts = list(list_page.object_list)
posters = []
threads = []
for post in posts:
threads.append(post.thread)
if post.poster:
posters.append(post.poster)
add_categories_to_items(root_category.unwrap(), threads_categories,
posts + threads)
add_acl(request.user, threads)
add_acl(request.user, posts)
threadstracker.make_threads_read_aware(request.user, threads)
for post in posts:
threadstracker.make_posts_read_aware(request.user, post.thread,
[post])
add_likes_to_posts(request.user, posts)
make_users_status_aware(request.user, posters)
self._user = request.user
self.posts = posts
self.paginator = paginator
def __init__(self, request, profile, page=0):
root_category = ThreadsRootCategory(request)
threads_categories = [root_category.unwrap()] + root_category.subcategories
threads_queryset = self.get_threads_queryset(
request, threads_categories, profile)
posts_queryset = self.get_posts_queryset(
request.user, profile, threads_queryset
).filter(
is_event=False,
is_hidden=False,
is_unapproved=False
).order_by('-pk')
list_page = paginate(
posts_queryset, page, settings.MISAGO_POSTS_PER_PAGE, settings.MISAGO_POSTS_TAIL)
paginator = pagination_dict(list_page, include_page_range=False)
posts = list(list_page.object_list)
posters = []
threads = []
for post in posts:
threads.append(post.thread)
if post.poster:
posters.append(post.poster)
add_categories_to_items(
root_category.unwrap(), threads_categories, posts + threads)
add_acl(request.user, threads)
add_acl(request.user, posts)
threadstracker.make_threads_read_aware(request.user, threads)
for post in posts:
threadstracker.make_posts_read_aware(request.user, post.thread, [post])
add_likes_to_posts(request.user, posts)
make_users_status_aware(request.user, posters)
self._user = request.user
self.posts = posts
self.paginator = 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(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 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)
