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 list(self, page=0):
queryset = exclude_invisible_threads(
self.user, self.forum, self.forum.thread_set)
queryset = self.filter_threads(queryset)
queryset = queryset.order_by(*self.sort_by)
announcements_qs = queryset.filter(weight=ANNOUNCEMENT)
threads_qs = queryset.filter(weight__lt=ANNOUNCEMENT)
self._page = paginate(threads_qs, page, 20, 10)
self._paginator = self._page.paginator
threads = []
for announcement in announcements_qs:
threads.append(announcement)
for thread in self._page.object_list:
threads.append(thread)
for thread in threads:
thread.forum = self.forum
self.label_threads(threads, self.forum.labels)
self.make_threads_read_aware(threads)
return threads
def __init__(self, request, category, list_type, page):
self.allow_see_list(request, category, list_type)
base_queryset = self.get_base_queryset(request, category.categories, list_type)
threads_categories = [category.category] + category.subcategories
threads_queryset = self.get_remaining_threads_queryset(base_queryset, category.category, threads_categories)
list_page = paginate(threads_queryset, page, settings.MISAGO_THREADS_PER_PAGE, settings.MISAGO_THREADS_TAIL)
paginator = pagination_dict(list_page, include_page_range=False)
if list_page.number > 1:
threads = list(list_page.object_list)
else:
pinned_threads = list(self.get_pinned_threads(base_queryset, category.category, 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_threads(category.category, category.categories, threads)
add_acl(request.user, threads)
make_subscription_aware(request.user, 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 rank(request, slug, page=0):
rank = get_object_or_404(Rank.objects.filter(is_tab=True), slug=slug)
queryset = rank.user_set.select_related('rank').order_by('slug')
if not request.user.is_staff:
queryset = queryset.filter(is_active=True)
page = paginate(queryset, page, settings.MISAGO_USERS_PER_PAGE, 4)
data = pagination_dict(page)
data.update({'results': UserSerializer(page.object_list, many=True).data})
request.frontend_context['USERS'] = data
if rank.description:
description = {
'plain': rank.description,
'html': format_plaintext_for_html(rank.description)
}
else:
description = None
template = "misago/userslists/rank.html"
return render(request, template, {
'rank': rank,
'users': page.object_list,
'paginator': data
})
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 list(self, page=0):
queryset = self.get_queryset()
queryset = queryset.order_by(self.sort_by)
pinned_qs = queryset.filter(is_pinned=True)
threads_qs = queryset.filter(is_pinned=False)
self._page = paginate(threads_qs, page, 20, 10)
self._paginator = self._page.paginator
threads = []
if self.fetch_pinned_threads:
for thread in pinned_qs:
threads.append(thread)
self.pinned_count += 1
for thread in self._page.object_list:
threads.append(thread)
for thread in threads:
thread.forum = self.forum
self.label_threads(threads, self.forum.labels)
self.make_threads_read_aware(threads)
return threads
def warnings(request, profile, page=0):
warnings_qs = profile.warnings.order_by('-id')
warnings = paginate(warnings_qs, page, 5, 2)
items_left = warnings.paginator.count - warnings.end_index()
add_acl(request.user, warnings.object_list)
warning_level = get_user_warning_level(profile)
warning_level_obj = get_user_warning_obj(profile)
active_warnings = warning_level - warnings.start_index() + 1
for warning in warnings.object_list:
if warning.is_canceled:
warning.is_active = False
else:
warning.is_active = active_warnings > 0
active_warnings -= 1
levels_total = len(get_warning_levels()) - 1
if levels_total and warning_level:
warning_progress = 100 - warning_level * 100 / levels_total
else:
warning_progress = 100
if warning_level:
warning_level_obj.level = warning_level
return render(request, 'misago/profile/warnings.html', {
'profile': profile,
'warnings': warnings,
'warning_level': warning_level_obj,
'warning_progress': warning_progress,
'page_number': warnings.number,
'items_left': items_left
})
def __init__(self, request, category, list_type, page):
self.allow_see_list(request, category, list_type)
base_queryset = self.get_base_queryset(request, category.categories, list_type)
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, include_page_range=False)
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_threads(category.model, category.categories, threads)
add_acl(request.user, threads)
make_subscription_aware(request.user, 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 rank(request, rank_slug, page=0):
rank = get_object_or_404(Rank.objects.filter(is_tab=True), slug=rank_slug)
queryset = rank.user_set.select_related('rank').order_by('slug')
page = paginate(queryset, page, settings.MISAGO_USERS_PER_PAGE, 4)
paginator = pagination_dict(page)
request.frontend_context['USERS'] = dict(
results=UserSerializer(page.object_list, many=True).data,
**paginator
)
if rank.description:
description = {
'plain': rank.description,
'html': format_plaintext_for_html(rank.description)
}
else:
description = None
template = "misago/userslists/rank.html"
return render(request, template, {
'rank': rank,
'users': page.object_list,
'paginator': paginator
})
def list(self, page=0):
queryset = self.get_queryset()
queryset = queryset.order_by(self.sort_by)
pinned_qs = queryset.filter(is_pinned=True)
threads_qs = queryset.filter(is_pinned=False)
self._page = paginate(threads_qs, page, 20, 10)
self._paginator = self._page.paginator
threads = []
if self.fetch_pinned_threads:
for thread in pinned_qs:
threads.append(thread)
self.pinned_count += 1
for thread in self._page.object_list:
threads.append(thread)
for thread in threads:
thread.forum = self.forum
self.label_threads(threads, self.forum.labels)
self.make_threads_read_aware(threads)
return threads
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 get_threads(self, request, kwargs):
queryset = self.get_threads_queryset(request, forum)
queryset = threads_qs.order_by('-last_post_id')
page = paginate(threads_qs, kwargs.get('page', 0), 30, 10)
threads = [thread for thread in page.object_list]
return page, threads
def test_paginated_response_data_serializer(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(
page,
data=['a', 'b', 'c', 'd'],
serializer=MockSerializer,
)
def test_paginated_response_data_serializer(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(
page,
data=['a', 'b', 'c', 'd'],
serializer=MockSerializer,
)
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_read_aware(request.user, posts)
self._user = request.user
self.posts = posts
self.paginator = paginator
def __init__(self, request, page=0):
problems = Problem.objects.all().select_related(
'thread', 'starter').order_by('-thread__started_on').all()
page_size = getattr(settings, 'OJ_PROBLEMS_PER_PAGE', 20)
list_page = paginate(problems, page, page_size, 4)
self.problems = list_page.object_list
for problem in self.problems:
problem.solutions = problem.solution_set.all().count()
self.paginator = pagination_dict(list_page)
self.count = len(self.problems)
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 name_history(request, profile, page=0):
name_changes_qs = profile.namechanges.all().order_by('-id')
name_changes = paginate(name_changes_qs, page, 12, 4)
items_left = name_changes.paginator.count - name_changes.end_index()
return render(request, 'misago/profile/name_history.html', {
'profile': profile,
'name_changes': name_changes,
'page_number': name_changes.number,
'items_left': items_left
})
def test_paginated_response_data_extra(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(
page,
data=['a', 'b', 'c', 'd'],
extra={
'next': 'EXTRA',
'lorem': 'ipsum',
},
)
def test_paginated_response_data_extra(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(
page,
data=['a', 'b', 'c', 'd'],
extra={
'next': 'EXTRA',
'lorem': 'ipsum',
},
)
def name_history(request, profile, page=0):
name_changes_qs = profile.namechanges.all().order_by('-id')
name_changes = paginate(name_changes_qs, page, 12, 4)
items_left = name_changes.paginator.count - name_changes.end_index()
return render(
request, 'misago/profile/name_history.html', {
'profile': profile,
'name_changes': name_changes,
'page_number': name_changes.number,
'items_left': items_left
})
def get_posts(self, user, forum, thread, kwargs):
queryset = self.get_posts_queryset(user, forum, thread)
page = paginate(queryset, kwargs.get('page', 0), 10, 5)
posts = []
for post in page.object_list:
add_acl(user, post)
if post.poster:
poster_state = get_user_state(post.poster, user.acl)
post.poster.online_state = poster_state
posts.append(post)
return page, posts
def follows(request, profile, page=0):
followers_qs = profile.follows.order_by('slug')
followers = paginate(followers_qs, page, 6 * 4, 6)
items_left = followers.paginator.count - followers.end_index()
if followers.paginator.count != profile.following:
profile.following = followers.paginator.count
profile.save(update_fields=['following'])
return render(request, 'misago/profile/follows.html', {
'profile': profile,
'followers': followers,
'items_left': items_left,
})
def follows(request, profile, page=0):
followers_qs = profile.follows.order_by('slug')
followers = paginate(followers_qs, page, 6 * 4, 6)
items_left = followers.paginator.count - followers.end_index()
if followers.paginator.count != profile.following:
profile.following = followers.paginator.count
profile.save(update_fields=['following'])
return render(request, 'misago/profile/follows.html', {
'profile': profile,
'followers': followers,
'items_left': items_left,
})
def follows(request, profile):
queryset = profile.follows.select_related('rank').order_by('slug')
page = paginate(queryset, None, settings.MISAGO_USERS_PER_PAGE, 4)
paginator = pagination_dict(page)
request.frontend_context['PROFILE_FOLLOWS'] = dict(
results=UserSerializer(page.object_list, many=True).data,
**paginator
)
return render(request, 'misago/profile/follows.html', {
'profile': profile,
'follows': page.object_list,
})
def __init__(self, request, rank, page=0):
queryset = rank.user_set.select_related(
'rank',
'ban_cache',
'online_tracker',
).order_by('slug')
if not request.user.is_staff:
queryset = queryset.filter(is_active=True)
list_page = paginate(queryset, page, settings.MISAGO_USERS_PER_PAGE, 4)
make_users_status_aware(request.user, list_page.object_list)
self.users = list_page.object_list
self.paginator = pagination_dict(list_page)
def followers(request, profile):
queryset = profile.followed_by.select_related('rank').order_by('slug')
page = paginate(queryset, None, 12, 4)
paginator = pagination_dict(page)
request.frontend_context['PROFILE_FOLLOWERS'] = dict(
results=UserSerializer(page.object_list, many=True).data, **paginator)
return render(
request, 'misago/profile/followers.html', {
'profile': profile,
'followers': page.object_list,
'count': paginator['count'],
})
def list(self, request):
page = get_int_or_404(request.query_params.get('page', 0))
if page == 1:
page = 0 # api allows explicit first page
queryset = self.get_queryset()
list_page = paginate(queryset, page, 12, 4)
data = pagination_dict(list_page)
data.update({
'results': UsernameChangeSerializer(list_page.object_list, many=True).data,
})
return Response(data)
def get_context_data(self, request, profile):
queryset = profile.namechanges.select_related('user', 'changed_by')
queryset = queryset.order_by('-id')
page = paginate(queryset, None, 14, 4)
data = pagination_dict(page)
data.update({'results': UsernameChangeSerializer(page.object_list, many=True).data})
request.frontend_context['PROFILE_NAME_HISTORY'] = data
return {
'history': page.object_list,
'count': data['count'],
}
def get_context_data(self, request, profile):
queryset = profile.namechanges.select_related('user', 'changed_by')
queryset = queryset.order_by('-id')
page = paginate(queryset, None, 14, 4)
data = pagination_dict(page)
data.update({'results': UsernameChangeSerializer(page.object_list, many=True).data})
request.frontend_context['PROFILE_NAME_HISTORY'] = data
return {
'history': page.object_list,
'count': data['count'],
}
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()
category = self.get_category(request)
self.allow_see_list(request, category, list_type)
subcategories = self.get_subcategories(request, category)
categories = [category] + subcategories
queryset = self.get_queryset(
request, categories, list_type).order_by('-last_post_on')
page = paginate(queryset, page, 24, 6, allow_explicit_first_page=True)
response_dict = pagination_dict(page, include_page_range=False)
if list_type in ('new', 'unread'):
"""we already know all threads on list are unread"""
threadstracker.make_unread(page.object_list)
else:
threadstracker.make_threads_read_aware(
request.user, page.object_list)
add_categories_to_threads(categories, page.object_list)
visible_subcategories = []
for thread in page.object_list:
if (thread.top_category 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, page.object_list)
return Response(dict(
results=ThreadListSerializer(page.object_list, many=True).data,
**response_dict))
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 name_history(request, profile):
queryset = profile.namechanges.select_related('user', 'changed_by')
queryset = queryset.order_by('-id')
page = paginate(queryset, None, settings.MISAGO_USERS_PER_PAGE, 4)
paginator = pagination_dict(page)
request.frontend_context['PROFILE_NAME_HISTORY'] = dict(
results=UsernameChangeSerializer(page.object_list, many=True).data,
**paginator
)
return render(request, 'misago/profile/name_history.html', {
'profile': profile,
'history': page.object_list,
})
def list(self, request):
page = get_int_or_404(request.query_params.get('page', 0))
if page == 1:
page = 0 # api allows explicit first page
queryset = self.get_queryset()
list_page = paginate(queryset, page, 12, 4)
data = pagination_dict(list_page)
data.update({
'results':
UsernameChangeSerializer(list_page.object_list, many=True).data,
})
return Response(data)
def followers(request, profile):
queryset = profile.followed_by.select_related('rank').order_by('slug')
page = paginate(queryset, None, 12, 4)
paginator = pagination_dict(page)
request.frontend_context['PROFILE_FOLLOWERS'] = dict(
results=UserSerializer(page.object_list, many=True).data,
**paginator
)
return render(request, 'misago/profile/followers.html', {
'profile': profile,
'followers': page.object_list,
'count': paginator['count'],
})
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 __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 search(self, query, page=1):
root_category = ThreadsRootCategory(self.request)
threads_categories = [root_category.unwrap()
] + root_category.subcategories
if len(query) > 2:
visible_threads = exclude_invisible_threads(
self.request.user, threads_categories, Thread.objects)
results = search_threads(self.request, query, visible_threads)
else:
results = []
list_page = paginate(
results,
page,
settings.MISAGO_POSTS_PER_PAGE,
settings.MISAGO_POSTS_TAIL,
allow_explicit_first_page=True,
)
paginator = pagination_dict(list_page)
posts = []
threads = []
if paginator['count']:
posts = list(
list_page.object_list.select_related('thread', 'poster',
'poster__rank'))
threads = []
for post in posts:
threads.append(post.thread)
add_categories_to_items(root_category.unwrap(), threads_categories,
posts + threads)
results = {
'results':
FeedSerializer(posts,
many=True,
context={
'user': self.request.user,
}).data,
}
results.update(paginator)
return results
def username_history(request, profile):
queryset = profile.namechanges.select_related('user', 'changed_by')
queryset = queryset.order_by('-id')
page = paginate(queryset, None, settings.MISAGO_USERS_PER_PAGE, 4)
paginator = pagination_dict(page)
request.frontend_context['PROFILE_NAME_HISTORY'] = dict(
results=UsernameChangeSerializer(page.object_list, many=True).data,
**paginator)
return render(
request, 'misago/profile/username_history.html', {
'profile': profile,
'history': page.object_list,
'count': paginator['count'],
})
def __init__(self, request, profile, page=0, search=None):
queryset = self.get_queryset(profile).select_related('rank').order_by('slug')
if not request.user.is_staff:
queryset = queryset.filter(is_active=True)
if search:
name_starts_with = search.strip().lower()
if name_starts_with:
queryset = queryset.filter(slug__startswith=name_starts_with)
else:
raise Http404()
list_page = paginate(queryset, page, settings.MISAGO_USERS_PER_PAGE, 4)
make_users_status_aware(request.user, list_page.object_list)
self.users = list_page.object_list
self.paginator = pagination_dict(list_page)
def search(self, query, page=1):
root_category = ThreadsRootCategory(self.request)
threads_categories = [root_category.unwrap()] + root_category.subcategories
if len(query) > 2:
visible_threads = exclude_invisible_threads(
self.request.user, threads_categories, Thread.objects
)
results = search_threads(self.request, query, visible_threads)
else:
results = []
list_page = paginate(
results,
page,
settings.MISAGO_POSTS_PER_PAGE,
settings.MISAGO_POSTS_TAIL,
allow_explicit_first_page=True,
)
paginator = pagination_dict(list_page)
posts = []
threads = []
if paginator['count']:
posts = list(list_page.object_list.select_related(
'thread', 'poster', 'poster__rank'
))
threads = []
for post in posts:
threads.append(post.thread)
add_categories_to_items(root_category.unwrap(), threads_categories, posts + threads)
results = {
'results': FeedSerializer(posts, many=True, context={
'user': self.request.user,
}).data,
}
results.update(paginator)
return results
def generic(request):
page = get_int_or_404(request.GET.get('page', 0))
if page == 1:
page = 0 # api allows explicit first page
allow_name_search = True
queryset = UserModel.objects
if not request.user.is_staff:
queryset = queryset.filter(is_active=True)
if request.query_params.get('followers'):
user_pk = get_int_or_404(request.query_params.get('followers'))
queryset = get_object_or_404(queryset, pk=user_pk).followed_by
elif request.query_params.get('follows'):
user_pk = get_int_or_404(request.query_params.get('follows'))
queryset = get_object_or_404(queryset, pk=user_pk).follows
elif request.query_params.get('rank'):
rank_pk = get_int_or_404(request.query_params.get('rank'))
rank = get_object_or_404(Rank.objects, pk=rank_pk, is_tab=True)
queryset = queryset.filter(rank=rank)
allow_name_search = False
else:
raise Http404() # don't use this api for searches
if request.query_params.get('name'):
name_starts_with = request.query_params.get('name').strip().lower()
if name_starts_with and allow_name_search:
queryset = queryset.filter(slug__startswith=name_starts_with)
else:
raise Http404()
queryset = queryset.select_related('rank', 'ban_cache',
'online_tracker').order_by('slug')
list_page = paginate(queryset, page, settings.MISAGO_USERS_PER_PAGE, 4)
make_users_status_aware(request.user, list_page.object_list)
return paginated_response(list_page, serializer=UserSerializer)
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('-id')
list_page = paginate(posts_queryset, page,
settings.MISAGO_POSTS_PER_PAGE,
settings.MISAGO_POSTS_TAIL)
paginator = pagination_dict(list_page)
posts = list(list_page.object_list)
threads = []
for post in posts:
threads.append(post.thread)
add_categories_to_items(root_category.unwrap(), threads_categories,
posts + threads)
add_acl(request.user, threads)
add_acl(request.user, posts)
self._user = request.user
self.posts = posts
self.paginator = paginator
def warnings(request, profile, page=0):
warnings_qs = profile.warnings.order_by('-id')
warnings = paginate(warnings_qs, page, 5, 2)
items_left = warnings.paginator.count - warnings.end_index()
add_acl(request.user, warnings.object_list)
warning_level = get_user_warning_level(profile)
warning_level_obj = get_user_warning_obj(profile)
active_warnings = warning_level - warnings.start_index() + 1
for warning in warnings.object_list:
if warning.is_canceled:
warning.is_active = False
else:
warning.is_active = active_warnings > 0
active_warnings -= 1
levels_total = len(get_warning_levels()) - 1
if levels_total and warning_level:
warning_progress = 100 - warning_level * 100 / levels_total
else:
warning_progress = 100
if warning_level:
warning_level_obj.level = warning_level
return render(
request, 'misago/profile/warnings.html', {
'profile': profile,
'warnings': warnings,
'warning_level': warning_level_obj,
'warning_progress': warning_progress,
'page_number': warnings.number,
'items_left': items_left
})
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 test_pagination(request, page=None):
items = range(15)
page = paginate(items, page, 5)
return HttpResponse(",".join([str(x) for x in page.object_list]))
def list_view(request, template, queryset, page, context=None):
context = context or {}
context['users'] = paginate(queryset, page, 6 * 3, 5)
return render(request, template, context)
def test_paginated_response_data(request):
data = range(100)
page = paginate(data, 2, 10)
return paginated_response(page, data=['a', 'b', 'c', 'd', 'e'])
def test_paginated_response_serializer(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(page, serializer=MockSerializer)
def test_pagination(request, page=None):
items = range(15)
page = paginate(items, page, 5)
return HttpResponse(",".join([str(x) for x in page.object_list]))
def test_paginated_response(request):
data = range(100)
page = paginate(data, 2, 10)
return paginated_response(page)
def test_paginated_response_serializer(request):
data = [0, 1, 2, 3]
page = paginate(data, 0, 10)
return paginated_response(page, serializer=MockSerializer)
def setUp(self):
self.page = paginate(range(500), 11, 20, 5)
self.context = Context({
'page': self.page,
'user': MockUser()
})
def test_paginated_response(request):
data = range(100)
page = paginate(data, 2, 10)
return paginated_response(page)
def list_view(request, template, queryset, page, context=None):
context = context or {}
context['users'] = paginate(queryset, page, 6 * 3, 5)
return render(request, template, context)
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_paginated_response_data(request):
data = range(100)
page = paginate(data, 2, 10)
return paginated_response(page, data=['a', 'b', 'c', 'd', 'e'])
def setUp(self):
self.page = paginate(range(500), 11, 20, 5)
self.context = Context({'page': self.page, 'user': MockUser()})
