- 
+ 
+
+
" + escape(code) + "") +def highlight_code(code, language, linenos=True, title=None): + linenos_option = 'linenums="1"' if linenos else "" + title_option = f'title="{title}"' if title else "" + options = f"{{.{language} {linenos_option} {title_option}}}" - -try: - import pygments - import pygments.lexers - import pygments.formatters - import pygments.util -except ImportError: - - def highlight_code(code, language, cssclass=None): - return _make_pre_code(code) - -else: - - def highlight_code(code, language, cssclass="codehilite", linenos=True): - try: - lexer = pygments.lexers.get_lexer_by_name(language) - except pygments.util.ClassNotFound: - return _make_pre_code(code) - - if linenos: - return mark_safe( - pygments.highlight( - code, - lexer, - pygments.formatters.HtmlFormatter( - cssclass=cssclass, linenos="table", wrapcode=True - ), - ) - ) - return mark_safe( - pygments.highlight( - code, - lexer, - pygments.formatters.HtmlFormatter(cssclass=cssclass, wrapcode=True), - ) - ) + value = f"```{options}\n{code}\n```\n" + return mark_safe(markdown(value)) diff --git a/judge/jinja2/__init__.py b/judge/jinja2/__init__.py index 93ab0ad..e24ea8c 100644 --- a/judge/jinja2/__init__.py +++ b/judge/jinja2/__init__.py @@ -22,6 +22,7 @@ from . import ( social, spaceless, timedelta, + comment, ) from . import registry diff --git a/judge/jinja2/comment.py b/judge/jinja2/comment.py new file mode 100644 index 0000000..6baa365 --- /dev/null +++ b/judge/jinja2/comment.py @@ -0,0 +1,12 @@ +from . import registry + +from django.contrib.contenttypes.models import ContentType + +from judge.models.comment import get_visible_comment_count +from judge.caching import cache_wrapper + + +@registry.function +def comment_count(obj): + content_type = ContentType.objects.get_for_model(obj) + return get_visible_comment_count(content_type, obj.pk) diff --git a/judge/jinja2/datetime.py b/judge/jinja2/datetime.py index eb0ec41..ce7cf32 100644 --- a/judge/jinja2/datetime.py +++ b/judge/jinja2/datetime.py @@ -23,5 +23,5 @@ registry.filter(localtime_wrapper(time)) @registry.function @registry.render_with("widgets/relative-time.html") -def relative_time(time, format=_("N j, Y, g:i a"), rel=_("{time}"), abs=_("on {time}")): +def relative_time(time, format=_("N j, Y, g:i a"), rel=_("{time}"), abs=_("{time}")): return {"time": time, "format": format, "rel_format": rel, "abs_format": abs} diff --git a/judge/jinja2/gravatar.py b/judge/jinja2/gravatar.py index b6e8a83..175992f 100644 --- a/judge/jinja2/gravatar.py +++ b/judge/jinja2/gravatar.py @@ -10,10 +10,11 @@ from . import registry @registry.function def gravatar(profile, size=80, default=None, profile_image=None, email=None): - if profile_image: - return profile_image - if profile and profile.profile_image_url: - return profile.profile_image_url + if profile and not profile.is_muted: + if profile_image: + return profile_image + if profile and profile.profile_image_url: + return profile.profile_image_url if profile: email = email or profile.email if default is None: diff --git a/judge/jinja2/markdown/__init__.py b/judge/jinja2/markdown/__init__.py index fa78791..18355d4 100644 --- a/judge/jinja2/markdown/__init__.py +++ b/judge/jinja2/markdown/__init__.py @@ -1,112 +1,7 @@ from .. import registry -import markdown as _markdown -import bleach -from django.utils.html import escape -from bs4 import BeautifulSoup -from pymdownx import superfences - - -EXTENSIONS = [ - "pymdownx.arithmatex", - "pymdownx.magiclink", - "pymdownx.betterem", - "pymdownx.details", - "pymdownx.emoji", - "pymdownx.inlinehilite", - "pymdownx.superfences", - "pymdownx.tasklist", - "markdown.extensions.footnotes", - "markdown.extensions.attr_list", - "markdown.extensions.def_list", - "markdown.extensions.tables", - "markdown.extensions.admonition", - "nl2br", - "mdx_breakless_lists", -] - -EXTENSION_CONFIGS = { - "pymdownx.superfences": { - "custom_fences": [ - { - "name": "sample", - "class": "no-border", - "format": superfences.fence_code_format, - } - ] - }, -} - -ALLOWED_TAGS = list(bleach.sanitizer.ALLOWED_TAGS) + [ - "img", - "center", - "iframe", - "div", - "span", - "table", - "tr", - "td", - "th", - "tr", - "pre", - "code", - "p", - "hr", - "h1", - "h2", - "h3", - "h4", - "h5", - "h6", - "thead", - "tbody", - "sup", - "dl", - "dt", - "dd", - "br", - "details", - "summary", -] - -ALLOWED_ATTRS = ["src", "width", "height", "href", "class", "open"] +from judge.markdown import markdown as _markdown @registry.filter def markdown(value, lazy_load=False): - extensions = EXTENSIONS - html = _markdown.markdown( - value, extensions=extensions, extension_configs=EXTENSION_CONFIGS - ) - - # Don't clean mathjax - hash_script_tag = {} - soup = BeautifulSoup(html, "html.parser") - for script_tag in soup.find_all("script"): - allow_math_types = ["math/tex", "math/tex; mode=display"] - if script_tag.attrs.get("type", False) in allow_math_types: - hash_script_tag[str(hash(str(script_tag)))] = str(script_tag) - - for hashed_tag in hash_script_tag: - tag = hash_script_tag[hashed_tag] - html = html.replace(tag, hashed_tag) - - html = bleach.clean(html, tags=ALLOWED_TAGS, attributes=ALLOWED_ATTRS) - - for hashed_tag in hash_script_tag: - tag = hash_script_tag[hashed_tag] - html = html.replace(hashed_tag, tag) - - if not html: - html = escape(value) - if lazy_load: - soup = BeautifulSoup(html, features="html.parser") - for img in soup.findAll("img"): - if img.get("src"): - img["data-src"] = img["src"] - img["src"] = "" - for img in soup.findAll("iframe"): - if img.get("src"): - img["data-src"] = img["src"] - img["src"] = "" - html = str(soup) - return '
{bef} => {aft}
\n" + + return render( + request, + "test_formatter/edit_test_formatter.html", + { + "title": _("Test Formatter"), + "check": 0, + "files_list": bef_file, + "file_name": filename, + "res": response, + }, + ) + + def post(self, request, *args, **kwargs): + action = request.POST.get("action") + if action == "convert": + try: + file = TestFormatterModel.objects.last() + filestr = str(file.file) + filename = filestr.split("/")[-1] + filepath = filestr.split("/")[0] + bef_inp_format = request.POST["bef_inp_format"] + bef_out_format = request.POST["bef_out_format"] + aft_inp_format = request.POST["aft_inp_format"] + aft_out_format = request.POST["aft_out_format"] + aft_file_name = request.POST["file_name"] + except KeyError: + return HttpResponseBadRequest("No data.") + + if filename != aft_file_name: + source_path = os.path.join(settings.MEDIA_ROOT, filestr) + new_path = os.path.join( + settings.MEDIA_ROOT, "test_formatter/" + aft_file_name + ) + os.rename(source_path, new_path) + filename = aft_file_name + + preview_data = { + "bef_inp_format": bef_inp_format, + "bef_out_format": bef_out_format, + "aft_inp_format": aft_inp_format, + "aft_out_format": aft_out_format, + "file_name": filename, + "file_path": filepath, + "file_str": filepath + "/" + filename, + } + + converted_zip = tf_logic.convert(preview_data) + + global file_path + file_path = converted_zip["file_path"] + + zip_instance = TestFormatterModel() + zip_instance.file = file_path + zip_instance.save() + + preview = tf_logic.preview(preview_data) + response = HttpResponse() + + for i in range(len(preview["bef_preview"])): + bef = preview["bef_preview"][i]["value"] + aft = preview["aft_preview"][i]["value"] + response.write(f"{bef} => {aft}
") + + return response + + elif action == "download": + return HttpResponse(file_path) + + return HttpResponseBadRequest("Invalid action") + + +class DownloadTestFormatter(View): + def get(self, request): + file_path = request.GET.get("file_path") + file_name = file_path.split("/")[-1] + preview_file = tf_logic.preview_file(file_path) + + response = "" + for i in range(len(preview_file)): + response = response + (f"{preview_file[i]}
\n") + + files_list = [preview_file[0], preview_file[1]] + + return render( + request, + "test_formatter/download_test_formatter.html", + { + "title": _("Test Formatter"), + "response": response, + "files_list": files_list, + "file_path": os.path.join(settings.MEDIA_ROOT, file_path), + "file_path_getnames": file_path, + "file_name": file_name, + }, + ) + + def post(self, request): + file_path = request.POST.get("file_path") + + with open(file_path, "rb") as zip_file: + response = HttpResponse(zip_file.read(), content_type="application/zip") + response[ + "Content-Disposition" + ] = f"attachment; filename={os.path.basename(file_path)}" + return response diff --git a/judge/views/test_formatter/tf_logic.py b/judge/views/test_formatter/tf_logic.py new file mode 100644 index 0000000..f981745 --- /dev/null +++ b/judge/views/test_formatter/tf_logic.py @@ -0,0 +1,116 @@ +import os +from judge.views.test_formatter import test_formatter as tf +from judge.views.test_formatter import tf_pattern as pattern + + +class TestSuite: + def __init__( + self, + file_id: str, + pattern_pair: pattern.PatternPair, + test_id_list: list, + extra_files: list, + ): + self.file_id = file_id + self.pattern_pair = pattern_pair + self.test_id_list = test_id_list + self.extra_files = extra_files + + @classmethod + def get_test_suite(cls, file_name: str, inp_format: str, out_format: str): + pattern_pair = pattern.PatternPair.from_string_pair(inp_format, out_format) + names = tf.get_names_in_archive(file_name) + test_id_list, extra_files = pattern_pair.matches( + names, returns="test_id_with_extra_files" + ) + return cls(file_name, pattern_pair, test_id_list, extra_files) + + def get_name_list(self, add_extra_info=False): + important_files = [] + + for index, t in enumerate(self.test_id_list): + inp_name = self.pattern_pair.x.get_name(t, index=index, use_index=True) + out_name = self.pattern_pair.y.get_name(t, index=index, use_index=True) + important_files.extend([inp_name, out_name]) + + result = [] + + for name in important_files: + if add_extra_info: + result.append({"value": name, "is_extra_file": False}) + else: + result.append(name) + + for name in self.extra_files: + if add_extra_info: + result.append({"value": name, "is_extra_file": True}) + else: + result.append(name) + + return result + + +def is_valid_file_type(file_name): + _, ext = os.path.splitext(file_name) + return ext in [".zip", ".ZIP"] + + +def preview(params): + bif = params["bef_inp_format"] + bof = params["bef_out_format"] + aif = params["aft_inp_format"] + aof = params["aft_out_format"] + file_str = params["file_str"] + + try: + test_suite = TestSuite.get_test_suite(file_str, bif, bof) + bef_preview = test_suite.get_name_list(add_extra_info=True) + try: + test_suite.pattern_pair = pattern.PatternPair.from_string_pair(aif, aof) + aft_preview = test_suite.get_name_list(add_extra_info=True) + return {"bef_preview": bef_preview, "aft_preview": aft_preview} + except: + return {"bef_preview": bef_preview, "aft_preview": []} + except: + test_suite = TestSuite.get_test_suite(file_id, "*", "*") + preview = test_suite.get_name_list(add_extra_info=True) + return {"bef_preview": preview, "aft_preview": []} + + +def convert(params): + bif = params["bef_inp_format"] + bof = params["bef_out_format"] + aif = params["aft_inp_format"] + aof = params["aft_out_format"] + file_str = params["file_str"] + file_name = params["file_name"] + file_path = params["file_path"] + + test_suite = TestSuite.get_test_suite(file_str, bif, bof) + bef_preview = test_suite.get_name_list() + test_suite.pattern_pair = pattern.PatternPair.from_string_pair(aif, aof) + aft_preview = test_suite.get_name_list() + + result = tf.get_renamed_archive( + file_str, file_name, file_path, bef_preview, aft_preview + ) + return result + + +def prefill(params): + file_str = params["file_str"] + file_name = params["file_name"] + + names = tf.get_names_in_archive(file_str) + pattern_pair = pattern.find_best_pattern_pair(names) + + return { + "file_name": file_name, + "inp_format": pattern_pair.x.to_string(), + "out_format": pattern_pair.y.to_string(), + } + + +def preview_file(file_str): + names = tf.get_names_in_archive(file_str) + return names diff --git a/judge/views/test_formatter/tf_pattern.py b/judge/views/test_formatter/tf_pattern.py new file mode 100644 index 0000000..071976d --- /dev/null +++ b/judge/views/test_formatter/tf_pattern.py @@ -0,0 +1,268 @@ +import os +import random +from judge.views.test_formatter import tf_utils as utils + +SAMPLE_SIZE = 16 +NUMBERED_MM = ["0", "1", "00", "01", "000", "001", "0000", "0001"] +VALID_MM = ["*"] + NUMBERED_MM + +MSG_TOO_MANY_OCCURRENCES = ( + "400: Invalid pattern: Pattern cannot have more than one '{}'" +) +MSG_MM_NOT_FOUND = "400: Invalid pattern: Wildcard not found. Wildcard list: {}" + + +class Pattern: + def __init__(self, ll, mm, rr): + assert mm in VALID_MM, "Invalid wildcard" + self.ll = ll + self.mm = mm + self.rr = rr + + def __repr__(self): + return "Pattern('{}', '{}', '{}')".format(self.ll, self.mm, self.rr) + + def __eq__(self, other): + return self.__repr__() == other.__repr__() + + def __hash__(self): + return self.__repr__().__hash__() + + @classmethod + def from_string(cls, text): + for mm in ["*"] + sorted(NUMBERED_MM, key=len, reverse=True): + if mm in text: + if text.count(mm) > 1: + raise Exception(MSG_TOO_MANY_OCCURRENCES.format(mm)) + i = text.index(mm) + return cls(text[:i], mm, text[i + len(mm) :]) + raise Exception(MSG_MM_NOT_FOUND.format(",".join(VALID_MM))) + + def to_string(self): + return self.ll + self.mm + self.rr + + def is_valid_test_id(self, test_id): + if self.mm == "*": + return True + if self.mm in NUMBERED_MM: + return test_id.isdigit() and len(test_id) >= len(self.mm) + raise NotImplementedError + + def matched(self, name): + return ( + name.startswith(self.ll) + and name.endswith(self.rr) + and len(name) >= len(self.ll) + len(self.rr) + and self.is_valid_test_id(self.get_test_id(name)) + ) + + def get_test_id(self, name): + return name[len(self.ll) : len(name) - len(self.rr)] + + def get_test_id_from_index(self, index): + assert self.mm in NUMBERED_MM, "Wildcard is not a number" + return str(int(self.mm) + index).zfill(len(self.mm)) + + def get_name(self, test_id, index=None, use_index=False): + if use_index and self.mm in NUMBERED_MM: + return self.ll + self.get_test_id_from_index(index) + self.rr + return self.ll + test_id + self.rr + + def matches(self, names, returns): + if returns == "test_id": + result = [n for n in names] + result = [n for n in result if self.matched(n)] + result = [self.get_test_id(n) for n in result] + return result + else: + raise NotImplementedError + + +class PatternPair: + def __init__(self, x: Pattern, y: Pattern): + assert x.mm == y.mm, "Input wildcard and output wildcard must be equal" + self.x = x + self.y = y + + def __repr__(self): + return "PatternPair({}, {})".format(self.x, self.y) + + def __eq__(self, other): + return self.__repr__() == other.__repr__() + + def __hash__(self): + return self.__repr__().__hash__() + + @classmethod + def from_string_pair(cls, inp_format, out_format): + return cls(Pattern.from_string(inp_format), Pattern.from_string(out_format)) + + def matches(self, names, returns): + x_test_ids = self.x.matches(names, returns="test_id") + y_test_ids = self.y.matches(names, returns="test_id") + + test_ids = set(x_test_ids) & set(y_test_ids) + test_ids = list(sorted(test_ids, key=utils.natural_sorting_key)) + + if returns == "fast_count": + if self.x.mm == "*": + return len(test_ids) + elif self.x.mm in NUMBERED_MM: + count_valid = 0 + for t in test_ids: + if t == self.x.get_test_id_from_index(count_valid): + count_valid += 1 + + return count_valid + + extra_files = list(names) + valid_test_ids = [] + for t in test_ids: + if self.x.mm in NUMBERED_MM: + if t != self.x.get_test_id_from_index(len(valid_test_ids)): + continue + + inp_name = self.x.get_name(t) + out_name = self.y.get_name(t) + + if inp_name == out_name: + continue + if inp_name not in extra_files: + continue + if out_name not in extra_files: + continue + + valid_test_ids.append(t) + extra_files.remove(inp_name) + extra_files.remove(out_name) + + if returns == "count": + return len(valid_test_ids) + elif returns == "test_id": + return valid_test_ids + elif returns == "test_id_with_extra_files": + return valid_test_ids, extra_files + else: + raise NotImplementedError + + def score(self, names): + def ls(s): + return len(s) - s.count("0") + + def zs(s): + return -s.count("0") + + def vs(s): + return sum( + s.lower().count(c) * w + for c, w in [("a", -1), ("e", -1), ("i", +1), ("o", -1), ("u", -1)] + ) + + count_score = self.matches(names, returns="fast_count") + + len_score = ls(self.x.ll + self.x.rr + self.y.ll + self.y.rr) + zero_score = zs(self.x.ll + self.x.rr + self.y.ll + self.y.rr) + + assert self.x.mm in ["*"] + NUMBERED_MM + specific_score = 0 if self.x.mm == "*" else len(self.x.mm) + + vowel_score = vs(self.x.ll + self.x.rr) - vs(self.y.ll + self.y.rr) + + return count_score, specific_score, len_score, zero_score, vowel_score + + def is_string_safe(self): + try: + x = Pattern.from_string(self.x.to_string()) + y = Pattern.from_string(self.y.to_string()) + return self == PatternPair(x, y) + except: + return False + + +def maximal(a, key): + max_score = max(map(key, a)) + result = [x for x in a if key(x) == max_score] + if len(result) == 1: + return result[0] + else: + print(result) + raise Exception("More than one maximum values") + + +def get_all_star_pattern_pairs(names): + sample = random.sample(names, min(len(names), SAMPLE_SIZE)) + + star_pattern_pairs = [] + + all_prefixes = [n[:i] for n in sample for i in range(len(n) + 1)] + all_prefixes = list(sorted(set(all_prefixes))) + all_suffixes = [n[i:] for n in sample for i in range(len(n) + 1)] + all_suffixes = list(sorted(set(all_suffixes))) + + for prefix in all_prefixes: + matched_names = [n for n in names if n.startswith(prefix)] + if len(matched_names) == 2: + mn0, mn1 = matched_names + for i in range(len(prefix) + 1): + x = Pattern(prefix[:i], "*", mn0[len(prefix) :]) + y = Pattern(prefix[:i], "*", mn1[len(prefix) :]) + star_pattern_pairs.append(PatternPair(x, y)) + + for suffix in all_suffixes: + matched_names = [n for n in names if n.endswith(suffix)] + if len(matched_names) == 2: + mn0, mn1 = matched_names + for i in range(len(suffix) + 1): + x = Pattern(mn0[: len(mn0) - len(suffix)], "*", suffix[i:]) + y = Pattern(mn1[: len(mn1) - len(suffix)], "*", suffix[i:]) + star_pattern_pairs.append(PatternPair(x, y)) + + star_pattern_pairs = list(set(star_pattern_pairs)) + return star_pattern_pairs + + +def get_variant_pattern_pairs(pp): + return [ + PatternPair(Pattern(pp.x.ll, mm, pp.x.rr), Pattern(pp.y.ll, mm, pp.y.rr)) + for mm in VALID_MM + ] + [ + PatternPair(Pattern(pp.y.ll, mm, pp.y.rr), Pattern(pp.x.ll, mm, pp.x.rr)) + for mm in VALID_MM + ] + + +def find_best_pattern_pair(names): + star_pattern_pairs = get_all_star_pattern_pairs(names) + star_pattern_pairs = [ + pp for pp in star_pattern_pairs if pp.matches(names, returns="fast_count") >= 2 + ] + # for pp in star_pattern_pairs: + # print(pp, pp.is_string_safe(), pp.score(names)) + + if len(star_pattern_pairs) == 0: + return PatternPair(Pattern("", "*", ""), Pattern("", "*", "")) + best_star_pattern_pair = maximal(star_pattern_pairs, key=lambda pp: pp.score(names)) + + pattern_pairs = get_variant_pattern_pairs(best_star_pattern_pair) + # for pp in pattern_pairs: + # print(pp, pp.is_string_safe(), pp.score(names)) + pattern_pairs = [pp for pp in pattern_pairs if pp.is_string_safe()] + best_pattern_pair = maximal(pattern_pairs, key=lambda pp: pp.score(names)) + + return best_pattern_pair + + +def list_dir_recursively(folder): + old_cwd = os.getcwd() + os.chdir(folder) + result = [] + for root, _, filenames in os.walk("."): + for filename in filenames: + result.append(os.path.join(root, filename)) + os.chdir(old_cwd) + return result + + +def test_with_dir(folder): + names = list_dir_recursively(folder) + print(folder, find_best_pattern_pair(names)) diff --git a/judge/views/test_formatter/tf_utils.py b/judge/views/test_formatter/tf_utils.py new file mode 100644 index 0000000..919b069 --- /dev/null +++ b/judge/views/test_formatter/tf_utils.py @@ -0,0 +1,15 @@ +def get_char_kind(char): + return 1 if char.isdigit() else 2 if char.isalpha() else 3 + + +def natural_sorting_key(name): + result = [] + last_kind = -1 + for char in name: + curr_kind = get_char_kind(char) + if curr_kind != last_kind: + result.append("") + result[-1] += char + last_kind = curr_kind + + return [x.zfill(16) if x.isdigit() else x for x in result] diff --git a/judge/views/user.py b/judge/views/user.py index db073f1..6feaffa 100644 --- a/judge/views/user.py +++ b/judge/views/user.py @@ -35,23 +35,42 @@ from django.views.generic import DetailView, ListView, TemplateView from django.template.loader import render_to_string from reversion import revisions -from judge.forms import UserForm, ProfileForm -from judge.models import Profile, Rating, Submission, Friend +from judge.forms import UserForm, ProfileForm, ProfileInfoForm +from judge.models import ( + Profile, + Rating, + Submission, + Friend, + ProfileInfo, + BlogPost, + Problem, + Contest, + Solution, +) from judge.performance_points import get_pp_breakdown from judge.ratings import rating_class, rating_progress from judge.tasks import import_users from judge.utils.problems import contest_completed_ids, user_completed_ids from judge.utils.ranker import ranker from judge.utils.unicode import utf8text +from judge.utils.users import ( + get_rating_rank, + get_points_rank, + get_awards, + get_contest_ratings, +) from judge.utils.views import ( QueryStringSortMixin, TitleMixin, generic_message, SingleObjectFormView, + DiggPaginatorMixin, ) from judge.utils.infinite_paginator import InfinitePaginationMixin +from judge.views.problem import ProblemList from .contests import ContestRanking + __all__ = [ "UserPage", "UserAboutPage", @@ -100,12 +119,12 @@ class UserPage(TitleMixin, UserMixin, DetailView): def get_title(self): return ( _("My account") - if self.request.user == self.object.user - else _("User %s") % self.object.user.username + if self.request.profile == self.object + else _("User %s") % self.object.username ) def get_content_title(self): - username = self.object.user.username + username = self.object.username css_class = self.object.css_class return mark_safe(f'{username}') @@ -142,22 +161,10 @@ class UserPage(TitleMixin, UserMixin, DetailView): rating = self.object.ratings.order_by("-contest__end_time")[:1] context["rating"] = rating[0] if rating else None - context["rank"] = ( - Profile.objects.filter( - is_unlisted=False, - performance_points__gt=self.object.performance_points, - ).count() - + 1 - ) + context["points_rank"] = get_points_rank(self.object) if rating: - context["rating_rank"] = ( - Profile.objects.filter( - is_unlisted=False, - rating__gt=self.object.rating, - ).count() - + 1 - ) + context["rating_rank"] = get_rating_rank(self.object) context["rated_users"] = Profile.objects.filter( is_unlisted=False, rating__isnull=False ).count() @@ -185,42 +192,9 @@ EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc) class UserAboutPage(UserPage): template_name = "user/user-about.html" - def get_awards(self, ratings): - result = {} - - sorted_ratings = sorted( - ratings, key=lambda x: (x.rank, -x.contest.end_time.timestamp()) - ) - - result["medals"] = [ - { - "label": rating.contest.name, - "ranking": rating.rank, - "link": reverse("contest_ranking", args=(rating.contest.key,)) - + "#!" - + self.object.username, - "date": date_format(rating.contest.end_time, _("M j, Y")), - } - for rating in sorted_ratings - if rating.rank <= 3 - ] - - num_awards = 0 - for i in result: - num_awards += len(result[i]) - - if num_awards == 0: - result = None - - return result - def get_context_data(self, **kwargs): context = super(UserAboutPage, self).get_context_data(**kwargs) - ratings = context["ratings"] = ( - self.object.ratings.order_by("-contest__end_time") - .select_related("contest") - .defer("contest__description") - ) + ratings = context["ratings"] = get_contest_ratings(self.object) context["rating_data"] = mark_safe( json.dumps( @@ -229,7 +203,9 @@ class UserAboutPage(UserPage): "label": rating.contest.name, "rating": rating.rating, "ranking": rating.rank, - "link": reverse("contest_ranking", args=(rating.contest.key,)), + "link": reverse("contest_ranking", args=(rating.contest.key,)) + + "#!" + + self.object.username, "timestamp": (rating.contest.end_time - EPOCH).total_seconds() * 1000, "date": date_format( @@ -244,7 +220,7 @@ class UserAboutPage(UserPage): ) ) - context["awards"] = self.get_awards(ratings) + context["awards"] = get_awards(self.object) if ratings: user_data = self.object.ratings.aggregate(Min("rating"), Max("rating")) @@ -288,19 +264,6 @@ class UserAboutPage(UserPage): return context - # follow/unfollow user - def post(self, request, user, *args, **kwargs): - try: - if not request.profile: - raise Exception("You have to login") - if request.profile.username == user: - raise Exception("Cannot make friend with yourself") - - following_profile = Profile.objects.get(user__username=user) - Friend.toggle_friend(request.profile, following_profile) - finally: - return HttpResponseRedirect(request.path_info) - class UserProblemsPage(UserPage): template_name = "user/user-problems.html" @@ -357,17 +320,49 @@ class UserProblemsPage(UserPage): return context -class UserBookMarkPage(UserPage): +class UserBookMarkPage(DiggPaginatorMixin, ListView, UserPage): template_name = "user/user-bookmarks.html" + context_object_name = "bookmarks" + paginate_by = 10 + + def get(self, request, *args, **kwargs): + self.current_tab = self.request.GET.get("tab", "problems") + self.user = self.object = self.get_object() + return super(UserBookMarkPage, self).get(request, *args, **kwargs) + + def get_queryset(self): + model = None + if self.current_tab == "posts": + model = BlogPost + elif self.current_tab == "contests": + model = Contest + elif self.current_tab == "editorials": + model = Solution + else: + model = Problem + + q = MakeBookMark.objects.filter(user=self.user).select_related("bookmark") + q = q.filter(bookmark__content_type=ContentType.objects.get_for_model(model)) + object_ids = q.values_list("bookmark__object_id", flat=True) + + res = model.objects.filter(id__in=object_ids) + if self.current_tab == "contests": + res = res.prefetch_related("organizations", "tags") + elif self.current_tab == "editorials": + res = res.select_related("problem") + + return res def get_context_data(self, **kwargs): context = super(UserBookMarkPage, self).get_context_data(**kwargs) - bookmark_list = MakeBookMark.objects.filter(user=self.object) - context["blogs"] = bookmark_list.filter(bookmark__page__startswith="b") - context["problems"] = bookmark_list.filter(bookmark__page__startswith="p") - context["contests"] = bookmark_list.filter(bookmark__page__startswith="c") - context["solutions"] = bookmark_list.filter(bookmark__page__startswith="s") + context["current_tab"] = self.current_tab + context["user"] = self.user + + context["page_prefix"] = ( + self.request.path + "?tab=" + self.current_tab + "&page=" + ) + context["first_page_href"] = self.request.path return context @@ -403,21 +398,25 @@ class UserPerformancePointsAjax(UserProblemsPage): @login_required def edit_profile(request): profile = request.profile + profile_info, created = ProfileInfo.objects.get_or_create(profile=profile) if request.method == "POST": form_user = UserForm(request.POST, instance=request.user) form = ProfileForm( request.POST, request.FILES, instance=profile, user=request.user ) + form_info = ProfileInfoForm(request.POST, instance=profile_info) if form_user.is_valid() and form.is_valid(): - with transaction.atomic(), revisions.create_revision(): + with revisions.create_revision(): form_user.save() form.save() + form_info.save() revisions.set_user(request.user) revisions.set_comment(_("Updated on site")) return HttpResponseRedirect(request.path) else: form_user = UserForm(instance=request.user) form = ProfileForm(instance=profile, user=request.user) + form_info = ProfileInfoForm(instance=profile_info) tzmap = settings.TIMEZONE_MAP @@ -428,9 +427,9 @@ def edit_profile(request): "require_staff_2fa": settings.DMOJ_REQUIRE_STAFF_2FA, "form_user": form_user, "form": form, + "form_info": form_info, "title": _("Edit profile"), "profile": profile, - "has_math_config": bool(settings.MATHOID_URL), "TIMEZONE_MAP": tzmap or "http://momentjs.com/static/img/world.png", "TIMEZONE_BG": settings.TIMEZONE_BG if tzmap else "#4E7CAD", }, @@ -457,14 +456,13 @@ class UserList(QueryStringSortMixin, InfinitePaginationMixin, TitleMixin, ListVi queryset = ( Profile.objects.filter(is_unlisted=False) .order_by(self.order, "id") - .select_related("user") .only( "display_rank", - "user__username", "points", "rating", "performance_points", "problem_count", + "about", ) ) if self.request.organization: @@ -472,11 +470,11 @@ class UserList(QueryStringSortMixin, InfinitePaginationMixin, TitleMixin, ListVi if (self.request.GET.get("friend") == "true") and self.request.profile: queryset = self.filter_friend_queryset(queryset) self.filter_friend = True - return queryset def get_context_data(self, **kwargs): context = super(UserList, self).get_context_data(**kwargs) + Profile.prefetch_profile_cache([u.id for u in context["users"]]) context["users"] = ranker( context["users"], rank=self.paginate_by * (context["page_obj"].number - 1) ) @@ -592,3 +590,17 @@ def toggle_darkmode(request): return HttpResponseBadRequest() request.session["darkmode"] = not request.session.get("darkmode", False) return HttpResponseRedirect(path) + + +@login_required +def toggle_follow(request, user): + if request.method != "POST": + raise Http404() + + profile_to_follow = get_object_or_404(Profile, user__username=user) + + if request.profile.id == profile_to_follow.id: + raise Http404() + + Friend.toggle_friend(request.profile, profile_to_follow) + return HttpResponseRedirect(reverse("user_page", args=(user,))) diff --git a/judge/views/volunteer.py b/judge/views/volunteer.py index 64c58f9..acd3469 100644 --- a/judge/views/volunteer.py +++ b/judge/views/volunteer.py @@ -19,15 +19,14 @@ def vote_problem(request): except Exception as e: return HttpResponseBadRequest() - with transaction.atomic(): - vote, _ = VolunteerProblemVote.objects.get_or_create( - voter=request.profile, - problem=problem, - defaults={"knowledge_points": 0, "thinking_points": 0}, - ) - vote.knowledge_points = knowledge_points - vote.thinking_points = thinking_points - vote.feedback = feedback - vote.types.set(types) - vote.save() + vote, _ = VolunteerProblemVote.objects.get_or_create( + voter=request.profile, + problem=problem, + defaults={"knowledge_points": 0, "thinking_points": 0}, + ) + vote.knowledge_points = knowledge_points + vote.thinking_points = thinking_points + vote.feedback = feedback + vote.types.set(types) + vote.save() return JsonResponse({}) diff --git a/judge/widgets/datetime.py b/judge/widgets/datetime.py index 15bb383..d205e1c 100644 --- a/judge/widgets/datetime.py +++ b/judge/widgets/datetime.py @@ -1,24 +1,49 @@ from django import forms +from django.templatetags.static import static +from django.utils.html import format_html +from django.forms.utils import flatatt +from django.utils.dateparse import parse_datetime, parse_date class DateTimePickerWidget(forms.DateTimeInput): - template_name = "widgets/datetimepicker.html" + input_type = "datetime-local" - def get_context(self, name, value, attrs): - datetimepicker_id = "datetimepicker_{name}".format(name=name) - if attrs is None: - attrs = dict() - attrs["data-target"] = "#{id}".format(id=datetimepicker_id) - attrs["class"] = "form-control datetimepicker-input" - context = super().get_context(name, value, attrs) - context["widget"]["datetimepicker_id"] = datetimepicker_id - return context + def render(self, name, value, attrs=None, renderer=None): + if value is None: + value = "" + elif isinstance(value, str): + # Attempt to parse the string back to datetime + parsed_date = parse_datetime(value) + if parsed_date is not None: + value = parsed_date.strftime("%Y-%m-%dT%H:%M") + else: + value = "" + else: + value = value.strftime("%Y-%m-%dT%H:%M") - @property - def media(self): - css_url = "/static/datetime-picker/datetimepicker.min.css" - js_url = "/static/datetime-picker/datetimepicker.full.min.js" - return forms.Media( - js=[js_url], - css={"screen": [css_url]}, + final_attrs = self.build_attrs( + attrs, {"type": self.input_type, "name": name, "value": value} ) + return format_html("