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 generic(request):
queryset = get_user_model().objects
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
if 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)
if request.query_params.get('name'):
name_starts_with = request.query_params.get('name').strip().lower()
if name_starts_with:
queryset = queryset.filter(slug__startswith=name_starts_with)
else:
raise Http404()
queryset = queryset.select_related('rank', 'ban_cache', 'online_tracker')
paginator = Paginator()
users = paginator.paginate_queryset(queryset.order_by('slug'), request)
make_users_status_aware(users, request.user.acl)
return paginator.get_paginated_response(
UserSerializer(users, many=True).data)
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 generic(request):
queryset = get_user_model().objects
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
if 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)
if request.query_params.get('name'):
name_starts_with = request.query_params.get('name').strip().lower()
if name_starts_with:
queryset = queryset.filter(slug__startswith=name_starts_with)
else:
raise Http404()
queryset = queryset.select_related('rank', 'ban_cache', 'online_tracker')
paginator = Paginator()
users = paginator.paginate_queryset(queryset.order_by('slug'), request)
make_users_status_aware(users, request.user.acl)
return paginator.get_paginated_response(
UserSerializer(users, many=True).data)
def create(self, request, thread_pk):
thread = self.get_thread(request, thread_pk).unwrap()
allow_reply_thread(request.user, thread)
post = Post(
thread=thread,
category=thread.category,
)
# Put them through posting pipeline
posting = PostingEndpoint(
request,
PostingEndpoint.REPLY,
thread=thread,
post=post,
)
if posting.is_valid():
user_posts = request.user.posts
posting.save()
# setup extra data for serialization
post.is_read = False
post.is_new = True
post.poster.posts = user_posts + 1
make_users_status_aware(request.user, [post.poster])
return Response(
PostSerializer(post, context={
'user': request.user
}).data)
else:
return Response(posting.errors, status=400)
def update(self, request, thread_pk, pk):
thread = self.get_thread_for_update(request, thread_pk)
post = self.get_post_for_update(request, thread, pk).model
allow_edit_post(request.user, post)
posting = PostingEndpoint(request,
PostingEndpoint.EDIT,
thread=thread.model,
post=post)
if posting.is_valid():
post_edits = post.edits
posting.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
if post.poster:
make_users_status_aware(request.user, [post.poster])
return Response(PostSerializer(post).data)
else:
return Response(posting.errors, status=400)
return Response({})
def __init__(self, request):
ranking = get_active_posters_ranking()
make_users_status_aware(request.user, ranking['users'], fetch_state=True)
self.count = ranking['users_count']
self.tracked_period = settings.MISAGO_RANKING_LENGTH
self.users = ranking['users']
def update(self, request, thread_pk, pk=None):
thread = self.get_thread(request, thread_pk).unwrap()
post = self.get_post(request, thread, pk).unwrap()
allow_edit_post(request.user, post)
posting = PostingEndpoint(
request,
PostingEndpoint.EDIT,
thread=thread,
post=post,
)
if posting.is_valid():
post_edits = post.edits
posting.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
if post.poster:
make_users_status_aware(request.user, [post.poster])
return Response(
PostSerializer(post, context={
'user': request.user
}).data)
else:
return Response(posting.errors, status=400)
def create(self, request, thread_pk):
thread = self.get_thread_for_update(request, thread_pk).model
allow_reply_thread(request.user, thread)
post = Post(thread=thread, category=thread.category)
# Put them through posting pipeline
posting = PostingEndpoint(
request,
PostingEndpoint.REPLY,
thread=thread,
post=post
)
if posting.is_valid():
user_posts = request.user.posts
posting.save()
# setup extra data for serialization
post.is_read = False
post.is_new = True
post.poster.posts = user_posts + 1
make_users_status_aware(request.user, [post.poster])
return Response(PostSerializer(post, context={'user': request.user}).data)
else:
return Response(posting.errors, status=400)
def update(self, request, thread_pk, pk):
thread = self.get_thread_for_update(request, thread_pk)
post = self.get_post_for_update(request, thread, pk).model
allow_edit_post(request.user, post)
posting = PostingEndpoint(
request,
PostingEndpoint.EDIT,
thread=thread.model,
post=post
)
if posting.is_valid():
post_edits = post.edits
posting.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
if post.poster:
make_users_status_aware(request.user, [post.poster])
return Response(PostSerializer(post, context={'user': request.user}).data)
else:
return Response(posting.errors, status=400)
return Response({})
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 __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):
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):
ranking = get_active_posters_ranking()
make_users_status_aware(request.user,
ranking['users'],
fetch_state=True)
self.count = ranking['users_count']
self.tracked_period = settings.MISAGO_RANKING_LENGTH
self.users = ranking['users']
def active(request):
ranking = get_active_posters_ranking()
make_users_status_aware(
ranking['users'], request.user.acl, fetch_state=True)
return Response({
'tracked_period': settings.MISAGO_RANKING_LENGTH,
'results': ScoredUserSerializer(ranking['users'], many=True).data,
'count': ranking['users_count']
})
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, problem):
ranking = get_solution_ranking(problem)
make_users_status_aware(request.user,
ranking['users'],
fetch_state=True)
self.problem = problem
self.count = ranking['users_count']
self.tracked_period = settings.MISAGO_RANKING_LENGTH
self.users = ranking['users']
self.participants = problem.solution_set.all().count()
def active(request):
ranking = get_active_posters_ranking()
make_users_status_aware(request.user, ranking['users'], fetch_state=True)
return Response({
'tracked_period':
settings.MISAGO_RANKING_LENGTH,
'results':
ScoredUserSerializer(ranking['users'], many=True).data,
'count':
ranking['users_count']
})
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 rank(request):
rank_slug = request.query_params.get('rank')
if not rank_slug:
raise Http404()
rank = get_object_or_404(Rank.objects, slug=rank_slug, is_tab=True)
queryset = rank.user_set.select_related(
'rank', 'ban_cache', 'online_tracker').order_by('slug')
paginator = Paginator()
users = paginator.paginate_queryset(queryset, request)
make_users_status_aware(users, request.user.acl)
return paginator.get_paginated_response(
UserSerializer(users, many=True).data)
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 __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 revert_post_endpoint(request, post):
edit = get_edit_by_pk(post, request.GET.get('edit'))
datetime = timezone.now()
post_edits = post.edits
post.edits_record.create(
category=post.category,
thread=post.thread,
edited_on=datetime,
editor=request.user,
editor_name=request.user.username,
editor_slug=request.user.slug,
editor_ip=request.user_ip,
edited_from=post.original,
edited_to=edit.edited_from,
)
parsing_result = common_flavour(request, post.poster, edit.edited_from)
post.original = parsing_result['original_text']
post.parsed = parsing_result['parsed_text']
update_post_checksum(post)
post.updated_on = datetime
post.edits = F('edits') + 1
post.last_editor = request.user
post.last_editor_name = request.user.username
post.last_editor_slug = request.user.slug
post.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
add_acl(request.user, post)
if post.poster:
make_users_status_aware(request.user, [post.poster])
return Response(PostSerializer(post, context={'user': request.user}).data)
def revert_post_endpoint(request, post):
edit = get_edit_by_pk(post, request.GET.get('edit'))
datetime = timezone.now()
post_edits = post.edits
post.edits_record.create(
category=post.category,
thread=post.thread,
edited_on=datetime,
editor=request.user,
editor_name=request.user.username,
editor_slug=request.user.slug,
editor_ip=request.user_ip,
edited_from=post.original,
edited_to=edit.edited_from,
)
parsing_result = common_flavour(request, post.poster, edit.edited_from)
post.original = parsing_result['original_text']
post.parsed = parsing_result['parsed_text']
update_post_checksum(post)
post.updated_on = datetime
post.edits = F('edits') + 1
post.last_editor = request.user
post.last_editor_name = request.user.username
post.last_editor_slug = request.user.slug
post.save()
post.is_read = True
post.is_new = False
post.edits = post_edits + 1
add_acl(request.user, post)
if post.poster:
make_users_status_aware(request.user, [post.poster])
return Response(PostSerializer(post, context={'user': request.user}).data)
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)
