def test_threads_no_subscription(self):
"""make mulitple threads sub aware for authenticated"""
threads = []
for i in range(10):
threads.append(self.post_thread(timezone.now() - timedelta(days=10)))
if i % 3 == 0:
self.user.subscription_set.create(
thread=threads[-1],
category=self.category,
last_read_on=timezone.now(),
send_email=False,
)
elif i % 2 == 0:
self.user.subscription_set.create(
thread=threads[-1],
category=self.category,
last_read_on=timezone.now(),
send_email=True,
)
make_subscription_aware(self.user, threads)
for i in range(10):
if i % 3 == 0:
self.assertFalse(threads[i].subscription.send_email)
elif i % 2 == 0:
self.assertTrue(threads[i].subscription.send_email)
else:
self.assertIsNone(threads[i].subscription)
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_threads_no_subscription(self):
"""make mulitple threads sub aware for authenticated"""
threads = []
for i in range(10):
threads.append(
self.post_thread(timezone.now() - timedelta(days=10)))
if i % 3 == 0:
self.user.subscription_set.create(
thread=threads[-1],
category=self.category,
last_read_on=timezone.now(),
send_email=False,
)
elif i % 2 == 0:
self.user.subscription_set.create(
thread=threads[-1],
category=self.category,
last_read_on=timezone.now(),
send_email=True,
)
make_subscription_aware(self.user, threads)
for i in range(10):
if i % 3 == 0:
self.assertFalse(threads[i].subscription.send_email)
elif i % 2 == 0:
self.assertTrue(threads[i].subscription.send_email)
else:
self.assertIsNone(threads[i].subscription)
def test_anon_threads_subscription(self):
"""make multiple threads list sub aware for anon"""
threads = []
for _ in range(10):
threads.append(self.post_thread(timezone.now() - timedelta(days=10)))
make_subscription_aware(self.anon, threads)
for thread in threads:
self.assertIsNone(thread.subscription)
def test_subscribed_thread(self):
"""make thread sub aware for authenticated"""
self.user.subscription_set.create(
thread=self.thread,
category=self.category,
last_read_on=timezone.now(),
send_email=True,
)
make_subscription_aware(self.user, self.thread)
self.assertTrue(self.thread.subscription.send_email)
def test_anon_threads_subscription(self):
"""make multiple threads list sub aware for anon"""
threads = []
for _ in range(10):
threads.append(
self.post_thread(timezone.now() - timedelta(days=10)))
make_subscription_aware(self.anon, threads)
for thread in threads:
self.assertIsNone(thread.subscription)
def test_subscribed_thread(self):
"""make thread sub aware for authenticated"""
self.user.subscription_set.create(
thread=self.thread,
category=self.category,
last_read_on=timezone.now(),
send_email=True,
)
make_subscription_aware(self.user, self.thread)
self.assertTrue(self.thread.subscription.send_email)
def test_threads_no_subscription(self):
"""make mulitple threads sub aware for authenticated"""
threads = []
for i in xrange(10):
threads.append(
self.post_thread(timezone.now() - timedelta(days=10)))
make_subscription_aware(self.user, threads)
for thread in threads:
self.assertIsNone(thread.subscription)
def test_threads_no_subscription(self):
"""make mulitple threads sub aware for authenticated"""
threads = []
for i in xrange(10):
threads.append(
self.post_thread(timezone.now() - timedelta(days=10)))
make_subscription_aware(self.user, threads)
for thread in threads:
self.assertIsNone(thread.subscription)
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 __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)
if list_type in ('new', 'unread'):
# we already know all threads on list are unread
threadstracker.make_unread(threads)
else:
threadstracker.make_threads_read_aware(request.user, threads)
add_categories_to_items(category_model, category.categories, threads)
add_acl(request.user, threads)
make_subscription_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_no_subscription(self):
"""make thread sub aware for authenticated"""
make_subscription_aware(self.user, self.thread)
self.assertIsNone(self.thread.subscription)
def test_anon_subscription(self):
"""make single thread sub aware for anon"""
make_subscription_aware(self.anon, self.thread)
self.assertIsNone(self.thread.subscription)
def get(self, request, **kwargs):
try:
page = int(request.GET.get('page', 0))
if page == 1:
page = None
except ValueError:
raise Http404()
list_type = kwargs['list_type']
categories = self.get_categories(request)
category = self.get_category(request, categories, **kwargs)
self.allow_see_list(request, category, list_type)
subcategories = self.get_subcategories(category, categories)
queryset = self.get_queryset(request, categories, list_type)
threads_categories = [category] + subcategories
rest_queryset = self.get_rest_queryset(queryset, threads_categories)
page = paginate(rest_queryset, page, 24, 6)
paginator = pagination_dict(page, include_page_range=False)
if page.number > 1:
threads = list(page.object_list)
else:
pinned_threads = self.get_pinned_threads(
queryset, threads_categories)
threads = list(pinned_threads) + list(page.object_list)
if list_type in ('new', 'unread'):
"""we already know all threads on list are unread"""
threadstracker.make_unread(threads)
else:
threadstracker.make_threads_read_aware(
request.user, threads)
add_categories_to_threads(category, categories, threads)
visible_subcategories = []
for thread in threads:
if (thread.top_category and
thread.category in threads_categories and
thread.top_category.pk not in visible_subcategories):
visible_subcategories.append(thread.top_category.pk)
category.subcategories = []
for subcategory in subcategories:
if subcategory.pk in visible_subcategories:
category.subcategories.append(subcategory)
add_acl(request.user, threads)
make_subscription_aware(request.user, threads)
request.frontend_context.update({
'THREADS': dict(
results=ThreadListSerializer(threads, many=True).data,
subcategories=[c.pk for c in category.subcategories],
**paginator),
'CATEGORIES': IndexCategorySerializer(categories, many=True).data,
})
if categories[0].special_role:
request.frontend_context['CATEGORIES'][0]['special_role'] = True
self.set_frontend_context(request)
return render(request, self.template_name, dict(
category=category,
list_type=list_type,
list_name=LISTS_NAMES[list_type],
threads=threads,
paginator=paginator,
count=paginator['count'],
**self.get_extra_context(request)
))
def retrieve(self, request, pk=None):
thread = self.get_thread(request.user, pk)
make_subscription_aware(request.user, thread)
return Response(ThreadSerializer(thread).data)
def get(self, request, **kwargs):
try:
page = int(request.GET.get('page', 0))
if page == 1:
page = None
except ValueError:
raise Http404()
list_type = kwargs['list_type']
categories = self.get_categories(request)
category = self.get_category(request, categories, **kwargs)
self.allow_see_list(request, category, list_type)
subcategories = self.get_subcategories(category, categories)
queryset = self.get_queryset(request, categories, list_type)
threads_categories = [category] + subcategories
rest_queryset = self.get_rest_queryset(queryset, threads_categories)
page = paginate(rest_queryset, page, 24, 6)
paginator = pagination_dict(page, include_page_range=False)
if page.number > 1:
threads = list(page.object_list)
else:
pinned_threads = self.get_pinned_threads(queryset,
threads_categories)
threads = list(pinned_threads) + list(page.object_list)
if list_type in ('new', 'unread'):
"""we already know all threads on list are unread"""
threadstracker.make_unread(threads)
else:
threadstracker.make_threads_read_aware(request.user, threads)
add_categories_to_threads(category, categories, threads)
visible_subcategories = []
for thread in threads:
if (thread.top_category and thread.category in threads_categories
and thread.top_category.pk not in visible_subcategories):
visible_subcategories.append(thread.top_category.pk)
category.subcategories = []
for subcategory in subcategories:
if subcategory.pk in visible_subcategories:
category.subcategories.append(subcategory)
add_acl(request.user, threads)
make_subscription_aware(request.user, threads)
request.frontend_context.update({
'THREADS':
dict(results=ThreadListSerializer(threads, many=True).data,
subcategories=[c.pk for c in category.subcategories],
**paginator),
'CATEGORIES':
IndexCategorySerializer(categories, many=True).data,
})
if categories[0].special_role:
request.frontend_context['CATEGORIES'][0]['special_role'] = True
self.set_frontend_context(request)
return render(
request, self.template_name,
dict(category=category,
list_type=list_type,
list_name=LISTS_NAMES[list_type],
threads=threads,
paginator=paginator,
count=paginator['count'],
**self.get_extra_context(request)))
def test_no_subscription(self):
"""make thread sub aware for authenticated"""
make_subscription_aware(self.user, self.thread)
self.assertIsNone(self.thread.subscription)
def test_anon_subscription(self):
"""make single thread sub aware for anon"""
make_subscription_aware(self.anon, self.thread)
self.assertIsNone(self.thread.subscription)
def __call__(self, request):
try:
page = int(request.query_params.get('page', 0))
except ValueError:
raise Http404()
list_type = request.query_params.get('list') or 'all'
if list_type not in LIST_TYPES:
raise Http404()
categories = self.get_categories(request)
category = self.get_category(request, categories)
self.allow_see_list(request, category, list_type)
subcategories = self.get_subcategories(category, categories)
queryset = self.get_queryset(request, categories, list_type)
threads_categories = [category] + subcategories
rest_queryset = self.get_rest_queryset(
category, queryset, threads_categories)
page = paginate(rest_queryset, page, 24, 6,
allow_explicit_first_page=True
)
response_dict = pagination_dict(page, include_page_range=False)
if page.number > 1:
threads = list(page.object_list)
else:
pinned_threads = self.get_pinned_threads(
category, queryset, threads_categories)
threads = list(pinned_threads) + list(page.object_list)
if list_type in ('new', 'unread'):
"""we already know all threads on list are unread"""
threadstracker.make_unread(threads)
else:
threadstracker.make_threads_read_aware(
request.user, threads)
add_categories_to_threads(category, categories, threads)
visible_subcategories = []
for thread in threads:
if (thread.top_category and
thread.category in threads_categories and
thread.top_category not in visible_subcategories):
visible_subcategories.append(thread.top_category.pk)
if self.serialize_subcategories:
response_dict['subcategories'] = []
for subcategory in subcategories:
if subcategory.pk in visible_subcategories:
response_dict['subcategories'].append(subcategory.pk)
add_acl(request.user, threads)
make_subscription_aware(request.user, threads)
return Response(dict(
results=ThreadListSerializer(threads, many=True).data,
**response_dict))
def retrieve(self, request, pk=None):
thread = self.get_thread(request.user, pk)
make_subscription_aware(request.user, thread)
return Response(ThreadSerializer(thread).data)
