def get_queryset(self):
user = self.request.user if self.request.user.is_authenticated else None
return Contest.objects.get_status_list(show_all=is_admin_or_root(
self.request.user),
filter_user=user,
sorting_by_id=True,
contest_type=1)
def get_queryset(self):
if 'exact' in self.request.GET:
self.search_text = q = self.request.GET['exact']
query = Q(pk__exact=q)
elif 'q' in self.request.GET:
self.search_text = q = self.request.GET['q']
query = Q(title__icontains=q) | Q(alias__icontains=q) | Q(
source__icontains=q)
if q.isdigit():
query |= Q(pk__exact=q)
self.id_searching_recommendation = q
else:
self.search_text = ''
query = None
if is_admin_or_root(self.request.user):
qs = Problem.objects.all()
else:
qs = self.request.user.managing_problems.all()
if query:
qs = qs.filter(query)
qs = qs.only("update_time", "title", "id", "create_time", "source", "alias") \
.order_by("-update_time").prefetch_related("revisions").annotate(Count('revisions'))
favorite_problems = set(
FavoriteProblem.objects.filter(user=self.request.user).values_list(
"problem_id", flat=True))
if favorite_problems:
for p in qs:
p.liked = p.id in favorite_problems
qs = sorted(list(qs), key=lambda p: not p.liked)
return qs
def post(self, request, pk):
if 'text' in request.POST and request.POST['text'] \
and (is_admin_or_root(self.request.user) or not review_requested()):
Comment.objects.create(text=request.POST['text'],
author=request.user,
blog_id=pk)
return redirect(reverse('blog:detail', kwargs={'pk': pk}))
def post(self, request, pk):
def get_next_identifier(identifiers):
from collections import deque
q = deque()
q.append('')
while q:
u = q.popleft()
if u and u not in identifiers:
return u
for i in range(ord('A'), ord('Z') + 1):
q.append(u + chr(i))
problems = list(
filter(
lambda x: x,
map(lambda x: x.strip(), request.POST['problems'].split(','))))
for problem in problems:
if not Problem.objects.filter(id=problem, visible=True).exists() and \
not is_admin_or_root(request.user) and \
not request.user.managing_problems.filter(id=problem).exists():
raise PermissionDenied
for problem in problems:
if self.contest.contestproblem_set.filter(
problem_id=problem).exists():
continue
identifier = get_next_identifier(
[x.identifier for x in self.contest.contestproblem_set.all()])
self.contest.contestproblem_set.create(problem_id=problem,
identifier=identifier)
reorder_contest_problem_identifiers(self.contest)
return HttpResponse()
def test_func(self):
if not is_admin_or_root(self.request.user):
return False
if path.commonpath([self.root, settings.MIRROR_DIR
]) != settings.MIRROR_DIR:
return False
return True
def is_site_closed(request):
if is_admin_or_root(request.user):
return False
if request.META.get("HTTP_HOST",
'').split(":")[0] in settings.WHITE_LIST_HOST:
return False
return True
def get_queryset(self):
try:
queryset = self.get_selected_from().select_related('problem', 'author'). \
only('pk', 'contest_id', 'create_time', 'author_id', 'author__username',
'author__magic', 'problem_id', 'problem__title', 'lang', 'status', 'status_time', 'status_percent',
'code_length', 'ip', 'cheat_tag', 'status_test', 'judge_server')
if not self.privileged and not self.contest_submission_visible and not is_admin_or_root(self.request.user):
queryset = queryset.filter(contest__isnull=True, problem__visible=True)
if 'user' in self.request.GET:
queryset = queryset.filter(author_id=self.request.GET['user'])
if self.allow_problem_query and 'problem' in self.request.GET:
queryset = queryset.filter(problem_id=self.reinterpret_problem_identifier(self.request.GET['problem']))
if 'lang' in self.request.GET:
queryset = queryset.filter(lang=self.request.GET['lang'])
if self.allow_verdict_query and 'verdict' in self.request.GET:
queryset = queryset.filter(status=int(self.request.GET['verdict'][1:]))
if self.distinct_by_author:
author_set = set()
res = []
for submission in queryset.all():
if submission.author_id not in author_set:
author_set.add(submission.author_id)
res.append(submission)
if self.query_number and len(res) >= self.query_number:
break
return res
else:
return queryset.all()[:self.query_number]
except Exception as e:
raise Http404(e)
def get_context_data(self, **kwargs):
context = super(BlogView, self).get_context_data(**kwargs)
context['blog'] = self.blog
context['is_privileged'] = is_admin_or_root(self.request.user) or self.request.user == self.blog.author
if context['is_privileged'] or not self.blog.hide_revisions:
context['blog_revisions'] = self.blog.revisions.select_related("author").all()[1:]
context['action_path'] = reverse('comments-post-comment')
return context
def form_valid(self, form):
instance = form.save(commit=False)
if not is_admin_or_root(
self.request.user) and instance.author != self.request.user:
raise PermissionDenied(_("You don't have the access."))
instance.save()
return HttpResponseRedirect(
reverse('blog:detail', kwargs={'pk': self.kwargs.get('pk')}))
def get_context_data(self, **kwargs):
context = super(BlogView, self).get_context_data(**kwargs)
context['blog'] = self.blog
context['action_path'] = reverse('comments-post-comment')
if is_admin_or_root(
self.request.user) or self.request.user == self.blog.author:
context['is_privileged'] = True
return context
def form_valid(self, form):
instance = form.save(commit=False)
if not is_admin_or_root(self.request.user) and instance.author != self.request.user:
raise PermissionDenied(_("You don't have the access."))
with transaction.atomic():
instance.save()
instance.revisions.create(title=instance.title, text=instance.text, author=self.request.user)
return redirect(reverse('blog:detail', kwargs=self.kwargs))
def remove_flag(request, **kwargs):
if kwargs['created'] and kwargs['flag'].flag == CommentFlag.SUGGEST_REMOVAL:
comment = kwargs['comment']
if is_admin_or_root(
request.user
) or request.user.is_authenticated and comment.user == request.user:
comment.is_removed = True
comment.save(update_fields=['is_removed'])
def get_queryset(self):
self.user = get_object_or_404(User, pk=self.kwargs.get('pk'))
qs = self.user.blog_set.all().with_likes().with_likes_flag(
self.request.user)
if not is_admin_or_root(
self.request.user) and not self.request.user == self.user:
qs = qs.filter(visible=True)
return qs
def get_context_data(self, **kwargs):
res = super(GenericView, self).get_context_data(**kwargs)
res['profile'] = self.user
res['solved'] = get_accept_problem_count(self.user.pk)
if is_admin_or_root(self.request.user):
res['is_privileged'] = True
if self.request.user == self.user:
res['is_author'] = res['is_privileged'] = True
return res
def get_context_data(self, **kwargs): # pylint: disable=arguments-differ
res = super(GetRewardsView, self).get_context_data(**kwargs)
res['profile'] = self.user
res['solved'] = get_accept_problem_count(self.user.pk)
if is_admin_or_root(self.request.user):
res['is_privileged'] = True
if self.request.user == self.user:
res['is_author'] = res['is_privileged'] = True
return res
def get_context_data(self, **kwargs):
data = super().get_context_data(**kwargs)
data["activity"] = get_object_or_404(Activity, id=self.kwargs["pk"])
data["registered"] = ActivityParticipant.objects.filter(activity_id=self.kwargs["pk"],
user_id=self.request.user.id,
is_deleted=False).exists()
data["register_open"] = data["activity"].register_start_time <= datetime.now() <= data["activity"].register_end_time
data["privileged"] = is_admin_or_root(self.request.user)
return data
def post(self, request, pk, comment_id):
instance = get_object_or_404(Comment, pk=comment_id)
if is_admin_or_root(request.user) or request.user == instance.author:
instance.delete()
elif instance.blog is not None and instance.blog.author == request.author:
instance.delete()
else:
return PermissionDenied(_("You don't have the access."))
return HttpResponseRedirect(reverse('blog:detail', kwargs={'pk': self.kwargs.get('pk')}))
def get(self, request):
kw = request.GET.get('kw')
results = dict()
if kw:
results['user'] = query_user(kw)
results['problem'] = query_problem(kw,
all=is_admin_or_root(
request.user))
return Response(dict(results=results))
def get(self, request):
kw = request.GET.get('kw')
managing = request.user if request.GET.get('managing') else None
results = list()
q = get_problem_q_object(kw, is_admin_or_root(request.user), managing)
if q:
for problem in Problem.objects.filter(q).distinct().all()[:5]:
results.append(dict(name=str(problem), value=problem.pk))
return Response(dict(success=True, results=results))
def post(self, request, pk):
if request.POST.get("answer") and is_admin_or_root(self.request.user):
activity = get_object_or_404(Activity, pk=request.POST["answer"])
with transaction.atomic():
for participant in activity.activityparticipant_set.filter(is_deleted=False):
p, _ = self.contest.contestparticipant_set.get_or_create(user=participant.user)
if not p.comment:
p.comment = participant.real_name
p.save(update_fields=['comment'])
return redirect(reverse('polygon:contest_participant', kwargs={"pk": self.contest.id}))
def form_valid(self, form):
instance = form.save(commit=False)
instance.author = self.request.user
if not is_admin_or_root(self.request.user) and review_requested():
instance.visible = False
instance.save()
instance.revisions.create(title=instance.title,
text=instance.text,
author=self.request.user)
return HttpResponseRedirect(
reverse('blog:index', kwargs={'pk': self.request.user.pk}))
def get_context_data(self, **kwargs):
context = super(BlogView, self).get_context_data(**kwargs)
if self.blog.is_reward:
context['submission'] = Submission.objects.get(
pk=self.blog.submission_id)
if self.blog.contest:
if self.request.user.id in self.blog.contest.participants_ids or \
self.request.user.id in self.blog.contest.managers or \
self.request.user.id in self.blog.contest.authors or is_admin_or_root(self.request.user):
pass
else:
raise PermissionDenied
context['blog'] = self.blog
context['is_privileged'] = is_admin_or_root(
self.request.user) or self.request.user == self.blog.author
if context['is_privileged'] or not self.blog.hide_revisions:
context['blog_revisions'] = self.blog.revisions.select_related(
"author").all()[1:]
context['action_path'] = reverse('comments-post-comment')
return context
def form_valid(self, form):
activity = get_object_or_404(Activity, id=self.kwargs["pk"])
if not (activity.register_start_time <= datetime.now() <= activity.register_end_time) and \
not is_admin_or_root(self.request.user):
raise PermissionDenied
if form.instance.activity_id is None:
form.instance.activity = activity
if form.instance.user_id is None:
form.instance.user = self.request.user
form.instance.is_deleted = False
return super().form_valid(form)
def get_context_data(self, **kwargs):
data = super().get_context_data(**kwargs)
for problem in data['problem_list']:
problem.latest_revision = self.get_problem_latest_revision(problem)
data['search_text'] = self.search_text
if hasattr(self, "id_searching_recommendation"):
pid = self.id_searching_recommendation
if Problem.objects.filter(id=pid).exists() and \
is_admin_or_root(self.request.user) or self.request.user.managing_problems.filter(id=pid).exists():
data["suggest_problem"] = Problem.objects.get(id=pid)
data["suggest_problem"].latest_revision = self.get_problem_latest_revision(data["suggest_problem"])
return data
def get_queryset(self):
try:
queryset = self.get_selected_from().select_related('problem', 'author'). \
only('pk', 'contest_id', 'create_time', 'author_id', 'author__username',
'author__magic', 'problem_id', 'problem__title', 'lang', 'status', 'status_time', 'status_percent',
'code_length', 'ip', 'status_test', 'status_memory', 'visible', 'judge_server', 'contest_time')
if 'user' in self.request.GET:
queryset = queryset.filter(author_id=self.request.GET['user'])
if self.allow_problem_query and 'problem' in self.request.GET:
problem_id = self.reinterpret_problem_identifier(
self.request.GET['problem'])
try:
if is_problem_manager(self.request.user,
Problem.objects.get(pk=problem_id)):
self.privileged = True
queryset = queryset.filter(problem_id=problem_id)
except:
pass
if 'lang' in self.request.GET:
queryset = queryset.filter(lang=self.request.GET['lang'])
if self.allow_verdict_query and 'verdict' in self.request.GET:
queryset = queryset.filter(
status=int(self.request.GET['verdict'][1:]))
if is_admin_or_root(self.request.user):
self.privileged = True
if not self.privileged:
queryset = queryset.filter(visible=True)
if not self.privileged and not self.contest_submission_visible:
queryset = queryset.filter(contest__isnull=True)
ordering = self.get_ordering()
if ordering is not None:
if isinstance(ordering, str):
ordering = (ordering, )
queryset = queryset.order_by(*ordering)
if self.distinct_by_author:
author_set = set()
res = []
for submission in queryset.all():
if submission.author_id not in author_set:
author_set.add(submission.author_id)
res.append(submission)
if self.query_number and len(res) >= self.query_number:
break
return res
else:
return queryset.all()[:self.query_number]
except Exception as e:
raise Http404(e)
def get(self, request):
kw = request.GET.get('kw')
results = dict()
if kw:
results['user'] = query_user(kw)
results['problem'] = query_problem(kw, all=is_admin_or_root(request.user))
results['tag'] = query_tag(kw)
results['blog'] = query_blog(kw)
results['contest'] = query_contest(kw)
return JsonResponse(dict(results=results, action={
"url": reverse('search') + '?q=%s' % kw,
"text": "View all results"
}))
return JsonResponse(dict(results=results))
def get_context_data(self, **kwargs):
data = super(StatusList, self).get_context_data(**kwargs)
user = self.request.user
data['keyword'] = self.request.GET.get('keyword')
data['param_verdict'], data['param_lang'], data['param_user'], data['param_problem'] = \
self.request.GET.get('verdict', ''), self.request.GET.get('lang', ''),\
self.request.GET.get('user', ''), self.request.GET.get('problem', '')
data['allow_verdict_query'] = self.allow_verdict_query
data['lang_choices'] = LANG_CHOICE
data['verdict_choices'] = STATUS_CHOICE
if user.is_authenticated:
for submission in data['submission_list']:
if is_admin_or_root(user) or submission.author == user:
submission.is_privileged = True
return data
def proxy_file_downloader(request):
if not is_admin_or_root(request.user):
raise PermissionDenied
def download_file(url):
local_filename = url.split('/')[-1]
if local_filename == '':
local_filename = random_string()
r = requests.get(url, stream=True, timeout=30)
with open(path.join(settings.UPLOAD_DIR, local_filename), 'wb') as f:
for chunk in r.iter_content(chunk_size=1024):
if chunk:
f.write(chunk)
if request.method == 'POST':
try:
url = request.POST['url']
Thread(target=download_file, args=(url, )).start()
except Exception as e:
raise PermissionDenied(repr(e))
return redirect(reverse('filemanager'))
def test_func(self):
if self.blog.is_reward:
if self.privileged:
return True
if self.contest.access_level == 0:
self.permission_denied_message = "比赛只对管理员可见。"
return False
if self.participate_contest_status < 0:
self.permission_denied_message = "尚未开始。"
return False
if self.registered or self.volunteer:
return True
else:
self.permission_denied_message = "你是不是忘了注册？"
return False
else:
if is_admin_or_root(self.user):
return True
if self.user == self.blog.author or self.blog.visible:
return True
return False
def file_manager(request):
def slugify(text):
import re
return re.sub(r'[ /"#!:]+', '_', text)
if not is_admin_or_root(request.user):
raise PermissionDenied
if request.method == 'POST':
try:
file = request.FILES['file']
save_uploaded_file_to(file,
settings.UPLOAD_DIR,
filename=slugify(file.name))
except Exception as e:
raise PermissionDenied(repr(e))
return render(
request,
'filemanager.jinja2',
context={
'file_list':
list(
map(
lambda x: {
'name':
x,
'modified_time':
datetime.fromtimestamp(
path.getmtime(path.join(settings.UPLOAD_DIR, x))).
strftime(settings.DATETIME_FORMAT_TEMPLATE),
'size':
str(
path.getsize(path.join(settings.UPLOAD_DIR, x)) //
1024) + "K"
},
filter(
lambda x: path.isfile(path.join(
settings.UPLOAD_DIR, x)),
listdir(settings.UPLOAD_DIR))))
})
