async def prepare(self):
self.session = await self.update_session()
if 'domain_id' in self.request.match_info:
self.domain_id = self.request.match_info.pop('domain_id')
if 'uid' in self.session:
uid = self.session['uid']
self.user, self.domain, self.domain_user, bdoc = await asyncio.gather(
user.get_by_uid(uid), domain.get(self.domain_id),
domain.get_user(self.domain_id, uid),
blacklist.get(self.remote_ip))
if not self.user:
raise error.UserNotFoundError(uid)
if not self.domain_user:
self.domain_user = {}
else:
self.domain, bdoc = await asyncio.gather(
domain.get(self.domain_id), blacklist.get(self.remote_ip))
self.view_lang = self.get_setting('view_lang')
try:
self.timezone = pytz.timezone(self.get_setting('timezone'))
except pytz.UnknownTimeZoneError:
pass
self.locale = locale.get(self.view_lang)
self.datetime_stamp = _datetime_stamp
if bdoc:
raise error.BlacklistedError(self.remote_ip)
if not self.GLOBAL and not self.has_priv(builtin.PRIV_VIEW_ALL_DOMAIN):
self.check_perm(builtin.PERM_VIEW)
async def get(self, *, pid: document.convert_doc_id):
# TODO(twd2): check status, eg. test, hidden problem, ...
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
pdoc = await problem.get(self.domain_id, pid, uid)
if pdoc.get('hidden', False):
self.check_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)
udoc, dudoc = await asyncio.gather(user.get_by_uid(pdoc['owner_uid']),
domain.get_user(self.domain_id, pdoc['owner_uid']))
if uid == None:
rdocs = []
else:
# TODO(iceboy): needs to be in sync with contest_detail_problem_submit
rdocs = await record \
.get_user_in_problem_multi(uid, self.domain_id, pdoc['doc_id']) \
.sort([('_id', -1)]) \
.limit(10) \
.to_list()
if not self.prefer_json:
path_components = self.build_path(
(self.translate('problem_main'), self.reverse_url('problem_main')),
(pdoc['title'], self.reverse_url('problem_detail', pid=pdoc['doc_id'])),
(self.translate('problem_submit'), None))
self.render('problem_submit.html', pdoc=pdoc, udoc=udoc, rdocs=rdocs, dudoc=dudoc,
page_title=pdoc['title'], path_components=path_components)
else:
self.json({'rdocs': rdocs})
async def get(self, *, rid: objectid.ObjectId):
rdoc = await record.get(rid)
if not rdoc:
raise error.RecordNotFoundError(rid)
rdoc['udoc'], rdoc['pdoc'] = await asyncio.gather(
user.get_by_uid(rdoc['uid']), problem.get(rdoc['domain_id'], rdoc['pid']))
self.render('record_detail.html', rdoc=rdoc)
async def get(self, *, tid: objectid.ObjectId, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(contest.get(self.domain_id, tid),
problem.get(self.domain_id, pid, uid))
tsdoc = await contest.get_status(self.domain_id, tdoc['doc_id'], self.user['_id'])
if not tsdoc or tsdoc.get('attend') != 1:
raise error.ContestNotAttendedError(tdoc['doc_id'])
if not self.is_live(tdoc):
raise error.ContestNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid, tdoc['doc_id'])
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, tdoc['doc_id'], self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if (contest.RULES[tdoc['rule']].show_func(tdoc, self.now)
or self.has_perm(builtin.PERM_VIEW_CONTEST_HIDDEN_STATUS)):
rdocs = await record.get_user_in_problem_multi(uid, self.domain_id, pdoc['doc_id']) \
.sort([('_id', -1)]) \
.limit(10) \
.to_list()
else:
rdocs = []
if not self.prefer_json:
path_components = self.build_path(
(self.translate('contest_main'), self.reverse_url('contest_main')),
(tdoc['title'], self.reverse_url('contest_detail', tid=tid)),
(pdoc['title'], self.reverse_url('contest_detail_problem', tid=tid, pid=pid)),
(self.translate('contest_detail_problem_submit'), None))
self.render('problem_submit.html', tdoc=tdoc, pdoc=pdoc, rdocs=rdocs,
tsdoc=tsdoc, udoc=udoc, attended=attended,
page_title=pdoc['title'], path_components=path_components)
else:
self.json({'rdocs': rdocs})
async def prepare(self):
self.translate = locale.get_translate(
options.default_locale) # Default translate for errors.
self.session = await self.update_session()
self.domain_id = self.request.match_info.pop('domain_id',
builtin.DOMAIN_ID_SYSTEM)
if 'uid' in self.session:
uid = self.session['uid']
self.user, self.domain, self.domain_user = await asyncio.gather(
user.get_by_uid(uid), domain.get(self.domain_id),
domain.get_user(self.domain_id, uid))
if not self.user:
raise error.UserNotFoundError(uid)
if not self.domain_user:
self.domain_user = {}
else:
self.user = builtin.USER_GUEST
self.domain = await domain.get(self.domain_id)
self.domain_user = builtin.DOMAIN_USER_GUEST
if not self.domain:
raise error.DomainNotFoundError(self.domain_id)
self.view_lang = self.get_setting('view_lang')
# TODO(iceboy): UnknownTimeZoneError
self.timezone = pytz.timezone(self.get_setting('timezone'))
self.translate = locale.get_translate(self.view_lang)
self.datetime_span = functools.partial(_datetime_span,
timezone=self.timezone)
self.datetime_stamp = _datetime_stamp
self.reverse_url = functools.partial(_reverse_url,
domain_id=self.domain_id)
self.build_path = functools.partial(_build_path,
domain_id=self.domain_id,
domain_name=self.domain['name'])
if not self.has_priv(builtin.PRIV_VIEW_ALL_DOMAIN):
self.check_perm(builtin.PERM_VIEW)
async def prepare(self):
self.session = await self.update_session()
if 'domain_id' in self.request.match_info:
self.domain_id = self.request.match_info.pop('domain_id')
if 'uid' in self.session:
uid = self.session['uid']
self.user, self.domain, self.domain_user, bdoc = await asyncio.gather(
user.get_by_uid(uid),
domain.get(self.domain_id),
domain.get_user(self.domain_id, uid),
blacklist.get(self.remote_ip))
if not self.user:
raise error.UserNotFoundError(uid)
if not self.domain_user:
self.domain_user = {}
else:
self.domain, bdoc = await asyncio.gather(
domain.get(self.domain_id), blacklist.get(self.remote_ip))
self.view_lang = self.get_setting('view_lang')
try:
self.timezone = pytz.timezone(self.get_setting('timezone'))
except pytz.UnknownTimeZoneError:
pass
self.locale = locale.get(self.view_lang)
self.datetime_stamp = _datetime_stamp
if bdoc:
raise error.BlacklistedError(self.remote_ip)
if not self.GLOBAL and not self.has_priv(builtin.PRIV_VIEW_ALL_DOMAIN):
self.check_perm(builtin.PERM_VIEW)
async def get(self, *, tid: objectid.ObjectId, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(contest.get(self.domain_id, document.TYPE_HOMEWORK, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, document.TYPE_HOMEWORK, tdoc['doc_id'], self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not attended:
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
if not self.is_ongoing(tdoc):
raise error.HomeworkNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid, tdoc['doc_id'])
if self.can_show_record(tdoc):
rdocs = await record.get_user_in_problem_multi(uid, self.domain_id, pdoc['doc_id'], get_hidden=True) \
.sort([('_id', -1)]) \
.limit(10) \
.to_list()
else:
rdocs = []
if not self.prefer_json:
path_components = self.build_path(
(self.translate('homework_main'), self.reverse_url('homework_main')),
(tdoc['title'], self.reverse_url('homework_detail', tid=tid)),
(pdoc['title'], self.reverse_url('homework_detail_problem', tid=tid, pid=pid)),
(self.translate('homework_detail_problem_submit'), None))
self.render('problem_submit.html', tdoc=tdoc, pdoc=pdoc, rdocs=rdocs,
tsdoc=tsdoc, udoc=udoc, attended=attended,
page_title=pdoc['title'], path_components=path_components)
else:
self.json({'rdocs': rdocs})
async def get(self, *, tid: objectid.ObjectId, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(contest.get(self.domain_id, document.TYPE_CONTEST, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, document.TYPE_CONTEST, tdoc['doc_id'], self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not attended:
raise error.ContestNotAttendedError(tdoc['doc_id'])
if not self.is_ongoing(tdoc):
raise error.ContestNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid, tdoc['doc_id'])
if self.can_show_record(tdoc):
rdocs = await record.get_user_in_problem_multi(uid, self.domain_id, pdoc['doc_id'], get_hidden=True) \
.sort([('_id', -1)]) \
.limit(10) \
.to_list()
else:
rdocs = []
if not self.prefer_json:
path_components = self.build_path(
(self.translate('contest_main'), self.reverse_url('contest_main')),
(tdoc['title'], self.reverse_url('contest_detail', tid=tid)),
(pdoc['title'], self.reverse_url('contest_detail_problem', tid=tid, pid=pid)),
(self.translate('contest_detail_problem_submit'), None))
self.render('problem_submit.html', tdoc=tdoc, pdoc=pdoc, rdocs=rdocs,
tsdoc=tsdoc, udoc=udoc, attended=attended,
page_title=pdoc['title'], path_components=path_components)
else:
self.json({'rdocs': rdocs})
async def get(self, *, tid: objectid.ObjectId,
pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(
builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, document.TYPE_HOMEWORK, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc, dudoc = await asyncio.gather(
contest.get_status(self.domain_id, document.TYPE_HOMEWORK,
tdoc['doc_id'], self.user['_id']),
user.get_by_uid(tdoc['owner_uid']),
domain.get_user(domain_id=self.domain_id, uid=tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not self.is_done(tdoc):
if not attended:
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
if not self.is_ongoing(tdoc):
raise error.HomeworkNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
path_components = self.build_path(
(self.translate('homework_main'),
self.reverse_url('homework_main')),
(tdoc['title'], self.reverse_url('homework_detail', tid=tid)),
(pdoc['title'], None))
self.render('problem_detail.html',
tdoc=tdoc,
pdoc=pdoc,
tsdoc=tsdoc,
udoc=udoc,
attended=attended,
dudoc=dudoc,
page_title=pdoc['title'],
path_components=path_components)
async def get(self, tid: objectid.ObjectId):
tdoc = await training.get(self.domain_id, tid)
pids = self.get_pids(tdoc)
# TODO(twd2): check status, eg. test, hidden problem, ...
owner_udoc, pdict, psdict = await asyncio.gather(
user.get_by_uid(tdoc['owner_uid']),
problem.get_dict(self.domain_id, pids),
problem.get_dict_status(self.domain_id, self.user['_id'], pids))
done_pids = set()
prog_pids = set()
for pid, psdoc in psdict.items():
if 'status' in psdoc:
if psdoc['status'] == constant.record.STATUS_ACCEPTED:
done_pids.add(pid)
else:
prog_pids.add(pid)
nsdict = {}
ndict = {}
done_nids = set()
for node in tdoc['dag']:
ndict[node['_id']] = node
total_count = len(node['pids'])
done_count = len(set(node['pids']) & set(done_pids))
nsdoc = {
'progress':
int(100 * done_count / total_count) if total_count else 100,
'is_done':
self.is_done(node, done_nids, done_pids),
'is_progress':
self.is_progress(node, done_nids, done_pids, prog_pids),
'is_open':
self.is_open(node, done_nids, done_pids, prog_pids),
'is_invalid':
self.is_invalid(node, done_nids)
}
if nsdoc['is_done']:
done_nids.add(node['_id'])
nsdict[node['_id']] = nsdoc
tsdoc = await training.set_status(self.domain_id,
tdoc['doc_id'],
self.user['_id'],
done_nids=list(done_nids),
done_pids=list(done_pids),
done=len(done_nids) == len(
tdoc['dag']))
path_components = self.build_path((self.translate('training_main'),
self.reverse_url('training_main')),
(tdoc['title'], None))
self.render('training_detail.html',
tdoc=tdoc,
tsdoc=tsdoc,
pids=pids,
pdict=pdict,
psdict=psdict,
ndict=ndict,
nsdict=nsdict,
owner_udoc=owner_udoc,
page_title=tdoc['title'],
path_components=path_components)
async def on_record_change(self, e):
rdoc = await record.get(objectid.ObjectId(e['value']))
# TODO(iceboy): join from event to improve performance?
# TODO(iceboy): projection.
rdoc['udoc'], rdoc['pdoc'] = await asyncio.gather(
user.get_by_uid(rdoc['uid']), problem.get(rdoc['domain_id'], rdoc['pid']))
# TODO(iceboy): check permission for visibility. (e.g. test).
self.send(html=self.render_html('record_tr.html', rdoc=rdoc))
async def on_record_change(self, e):
rdoc = await record.get(objectid.ObjectId(e['value']))
# TODO(iceboy): join from event to improve performance?
# TODO(iceboy): projection.
rdoc['udoc'], rdoc['pdoc'] = await asyncio.gather(
user.get_by_uid(rdoc['uid']), problem.get(rdoc['domain_id'], rdoc['pid']))
# TODO(iceboy): check permission for visibility. (e.g. test).
self.send(html=self.render_html('record_tr.html', rdoc=rdoc))
async def get(self, *, rid: objectid.ObjectId):
rdoc = await record.get(rid)
if not rdoc:
raise error.RecordNotFoundError(rid)
# TODO(iceboy): Check domain permission, permission for visibility in place.
if rdoc['domain_id'] != self.domain_id:
self.redirect(
self.reverse_url('record_detail',
rid=rid,
domain_id=rdoc['domain_id']))
return
# check permission for visibility: contest
show_status = True
if rdoc['tid']:
now = datetime.datetime.utcnow()
try:
tdoc = await contest.get(rdoc['domain_id'], rdoc['tid'])
show_status = contest.RULES[tdoc['rule']].show_func(tdoc, now) \
or self.has_perm(builtin.PERM_VIEW_CONTEST_HIDDEN_STATUS)
except error.DocumentNotFoundError:
tdoc = None
else:
tdoc = None
# TODO(twd2): futher check permission for visibility.
if (not self.own(rdoc, field='uid')
and not self.has_perm(builtin.PERM_READ_RECORD_CODE)
and not self.has_priv(builtin.PRIV_READ_RECORD_CODE)):
del rdoc['code']
if not show_status and 'code' not in rdoc:
raise error.PermissionError(
builtin.PERM_VIEW_CONTEST_HIDDEN_STATUS)
udoc, dudoc = await asyncio.gather(
user.get_by_uid(rdoc['uid']),
domain.get_user(self.domain_id, rdoc['uid']))
try:
pdoc = await problem.get(rdoc['domain_id'], rdoc['pid'])
except error.ProblemNotFoundError:
pdoc = {}
if show_status and 'judge_uid' in rdoc:
judge_udoc = await user.get_by_uid(rdoc['judge_uid'])
else:
judge_udoc = None
# check permission for visibility: hidden problem
if pdoc.get(
'hidden',
False) and not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
pdoc = None
self.render('record_detail.html',
rdoc=rdoc,
udoc=udoc,
dudoc=dudoc,
pdoc=pdoc,
tdoc=tdoc,
judge_udoc=judge_udoc,
show_status=show_status)
async def get(self, *, rid: objectid.ObjectId):
rdoc = await record.get(rid)
if not rdoc:
raise error.RecordNotFoundError(rid)
# TODO(iceboy): Check domain permission, permission for visibility in place.
if rdoc['domain_id'] != self.domain_id:
self.redirect(
self.reverse_url('record_detail',
rid=rid,
domain_id=rdoc['domain_id']))
return
if rdoc['tid']:
show_status, tdoc = await self.rdoc_contest_visible(rdoc)
else:
show_status, tdoc = True, None
# TODO(twd2): futher check permission for visibility.
if (not self.own(rdoc, field='uid')
and not self.has_perm(builtin.PERM_READ_RECORD_CODE)
and not self.has_priv(builtin.PRIV_READ_RECORD_CODE)):
del rdoc['code']
if not show_status and 'code' not in rdoc:
if tdoc['doc_type'] == document.TYPE_CONTEST:
raise error.PermissionError(
builtin.PERM_VIEW_CONTEST_HIDDEN_SCOREBOARD)
else: # TYPE_HOMEWORK
raise error.PermissionError(
builtin.PERM_VIEW_HOMEWORK_HIDDEN_SCOREBOARD)
udoc, dudoc = await asyncio.gather(
user.get_by_uid(rdoc['uid']),
domain.get_user(self.domain_id, rdoc['uid']))
try:
pdoc = await problem.get(rdoc['domain_id'], rdoc['pid'])
except error.ProblemNotFoundError:
pdoc = {}
if show_status and 'judge_uid' in rdoc:
judge_udoc = await user.get_by_uid(rdoc['judge_uid'])
else:
judge_udoc = None
# check permission for visibility: hidden problem
if pdoc.get(
'hidden',
False) and not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
pdoc = None
url_prefix = '/d/{}'.format(urllib.parse.quote(self.domain_id))
self.render('record_detail.html',
rdoc=rdoc,
udoc=udoc,
dudoc=dudoc,
pdoc=pdoc,
tdoc=tdoc,
judge_udoc=judge_udoc,
show_status=show_status,
socket_url=url_prefix +
'/records/{}/conn'.format(rid)) # FIXME(twd2): magic
async def get(self, *, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
pdoc = await problem.get(self.domain_id, pid, uid)
if not self.own(pdoc, builtin.PERM_EDIT_PROBLEM_SELF):
self.check_perm(builtin.PERM_EDIT_PROBLEM)
udoc, dudoc = await asyncio.gather(user.get_by_uid(pdoc['owner_uid']),
domain.get_user(self.domain_id, pdoc['owner_uid']))
path_components = self.build_path(
(self.translate('problem_main'), self.reverse_url('problem_main')),
(pdoc['title'], self.reverse_url('problem_detail', pid=pdoc['doc_id'])),
(self.translate('problem_edit'), None))
self.render('problem_edit.html', pdoc=pdoc, udoc=udoc, dudoc=dudoc,
page_title=pdoc['title'], path_components=path_components)
async def get(self, *, pid: document.convert_doc_id):
# TODO(twd2)
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
pdoc = await problem.get(self.domain_id, pid, uid)
if pdoc.get('hidden', False):
self.check_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)
udoc, dudoc = await asyncio.gather(user.get_by_uid(pdoc['owner_uid']),
domain.get_user(self.domain_id, pdoc['owner_uid']))
path_components = self.build_path(
(self.translate('problem_main'), self.reverse_url('problem_main')),
(pdoc['title'], self.reverse_url('problem_detail', pid=pdoc['doc_id'])),
(self.translate('problem_statistics'), None))
self.render('problem_statistics.html', pdoc=pdoc, udoc=udoc, dudoc=dudoc,
page_title=pdoc['title'], path_components=path_components)
async def get(self, *, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
pdoc = await problem.get(self.domain_id, pid, uid)
if pdoc.get('hidden', False):
self.check_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)
udoc, dudoc = await asyncio.gather(user.get_by_uid(pdoc['owner_uid']),
domain.get_user(self.domain_id, pdoc['owner_uid']))
tdocs, ctdocs, htdocs = await asyncio.gather(self._get_related_trainings(pid),
self._get_related_contests(pid),
self._get_related_homework(pid))
path_components = self.build_path(
(self.translate('problem_main'), self.reverse_url('problem_main')),
(pdoc['title'], None))
self.render('problem_detail.html', pdoc=pdoc, udoc=udoc, dudoc=dudoc,
tdocs=tdocs, ctdocs=ctdocs, htdocs=htdocs,
page_title=pdoc['title'], path_components=path_components)
async def get(self, *, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
pdoc = await problem.get(self.domain_id, pid, uid)
if pdoc.get('hidden', False):
self.check_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)
udoc, dudoc = await asyncio.gather(user.get_by_uid(pdoc['owner_uid']),
domain.get_user(self.domain_id, pdoc['owner_uid']))
tdocs = await training.get_multi(self.domain_id, **{'dag.pids': pid}).to_list() \
if self.has_perm(builtin.PERM_VIEW_TRAINING) else None
ctdocs = await contest.get_multi(self.domain_id, pids=pid).to_list() \
if self.has_perm(builtin.PERM_VIEW_CONTEST) else None
path_components = self.build_path(
(self.translate('problem_main'), self.reverse_url('problem_main')),
(pdoc['title'], None))
self.render('problem_detail.html', pdoc=pdoc, udoc=udoc, tdocs=tdocs, ctdocs=ctdocs,
dudoc=dudoc, page_title=pdoc['title'], path_components=path_components)
async def get(self, tid: objectid.ObjectId):
tdoc = await training.get(self.domain_id, tid)
pids = self.get_pids(tdoc)
# TODO(twd2): check status, eg. test, hidden problem, ...
if not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
f = {'hidden': False}
else:
f = {}
owner_udoc, owner_dudoc, pdict = await asyncio.gather(
user.get_by_uid(tdoc['owner_uid']),
domain.get_user(domain_id=self.domain_id, uid=tdoc['owner_uid']),
problem.get_dict(self.domain_id, pids, **f))
psdict = await problem.get_dict_status(self.domain_id,
self.user['_id'], pdict.keys())
done_pids = set()
prog_pids = set()
for pid, psdoc in psdict.items():
if 'status' in psdoc:
if psdoc['status'] == constant.record.STATUS_ACCEPTED:
done_pids.add(pid)
else:
prog_pids.add(pid)
nsdict = {}
ndict = {}
done_nids = set()
for node in tdoc['dag']:
ndict[node['_id']] = node
total_count = len(node['pids'])
done_count = len(set(node['pids']) & set(done_pids))
nsdoc = {'progress': int(100 * done_count / total_count) if total_count else 100,
'is_done': self.is_done(node, done_nids, done_pids),
'is_progress': self.is_progress(node, done_nids, done_pids, prog_pids),
'is_open': self.is_open(node, done_nids, done_pids, prog_pids),
'is_invalid': self.is_invalid(node, done_nids)}
if nsdoc['is_done']:
done_nids.add(node['_id'])
nsdict[node['_id']] = nsdoc
tsdoc = await training.set_status(self.domain_id, tdoc['doc_id'], self.user['_id'],
done_nids=list(done_nids), done_pids=list(done_pids),
done=len(done_nids) == len(tdoc['dag']))
path_components = self.build_path(
(self.translate('training_main'), self.reverse_url('training_main')),
(tdoc['title'], None))
self.render('training_detail.html', tdoc=tdoc, tsdoc=tsdoc, pids=pids,
pdict=pdict, psdict=psdict, ndict=ndict, nsdict=nsdict,
owner_udoc=owner_udoc, owner_dudoc=owner_dudoc,
page_title=tdoc['title'], path_components=path_components)
async def on_record_change(self, e):
rdoc = e['value']
for key, value in self.query.items():
if rdoc[key] != value:
return
if rdoc['tid']:
show_status, tdoc = await self.rdoc_contest_visible(rdoc)
if not show_status:
return
# TODO(iceboy): projection.
udoc, pdoc = await asyncio.gather(user.get_by_uid(rdoc['uid']),
problem.get(rdoc['domain_id'], rdoc['pid']))
# check permission for visibility: hidden problem
if pdoc.get('hidden', False) and (pdoc['domain_id'] != self.domain_id
or not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)):
pdoc = None
self.send(html=self.render_html('record_main_tr.html', rdoc=rdoc, udoc=udoc, pdoc=pdoc))
async def get(self, *, ctype: str, tid: objectid.ObjectId,
pid: document.convert_doc_id):
doc_type = constant.contest.CTYPE_TO_DOCTYPE[ctype]
uid = self.user['_id'] if self.has_priv(
builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, doc_type, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, doc_type, tdoc['doc_id'],
self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not self.is_finished(tdoc):
if not attended:
if ctype == 'contest':
raise error.ContestNotAttendedError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if not self.is_ongoing(tdoc):
if ctype == 'contest':
raise error.ContestNotLiveError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotLiveError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
path_components = self.build_path(
(self.translate('page.contest_main.{0}.title'.format(ctype)),
self.reverse_url('contest_main', ctype=ctype)),
(tdoc['title'],
self.reverse_url('contest_detail', ctype=ctype, tid=tid)),
(pdoc['title'], None))
self.render('problem_detail.html',
tdoc=tdoc,
pdoc=pdoc,
tsdoc=tsdoc,
udoc=udoc,
attended=attended,
page_title=pdoc['title'],
path_components=path_components)
async def on_record_change(self, e):
rdoc = e['value']
for key, value in self.query.items():
if rdoc[key] != value:
return
if rdoc['tid']:
show_status, tdoc = await self.rdoc_contest_visible(rdoc)
if not show_status:
return
# TODO(iceboy): projection.
udoc, dudoc, pdoc = await asyncio.gather(user.get_by_uid(rdoc['uid']),
domain.get_user(self.domain_id, rdoc['uid']),
problem.get(rdoc['domain_id'], rdoc['pid']))
# check permission for visibility: hidden problem
if pdoc.get('hidden', False) and (pdoc['domain_id'] != self.domain_id
or not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)):
pdoc = None
self.send(html=self.render_html('record_main_tr.html', rdoc=rdoc, udoc=udoc, dudoc=dudoc, pdoc=pdoc))
async def get(self, *, rid: objectid.ObjectId):
rdoc = await record.get(rid)
if not rdoc:
raise error.RecordNotFoundError(rid)
# TODO(iceboy): Check domain permission, permission for visibility in place.
if rdoc['domain_id'] != self.domain_id:
self.redirect(self.reverse_url('record_detail', rid=rid, domain_id=rdoc['domain_id']))
return
if rdoc['tid']:
show_status, tdoc = await self.rdoc_contest_visible(rdoc)
else:
show_status, tdoc = True, None
# TODO(twd2): futher check permission for visibility.
if (not self.own(rdoc, field='uid')
and not self.has_perm(builtin.PERM_READ_RECORD_CODE)
and not self.has_priv(builtin.PRIV_READ_RECORD_CODE)):
del rdoc['code']
if not show_status and 'code' not in rdoc:
if tdoc['doc_type'] == document.TYPE_CONTEST:
raise error.PermissionError(builtin.PERM_VIEW_CONTEST_HIDDEN_SCOREBOARD)
else: # TYPE_HOMEWORK
raise error.PermissionError(builtin.PERM_VIEW_HOMEWORK_HIDDEN_SCOREBOARD)
udoc, dudoc = await asyncio.gather(
user.get_by_uid(rdoc['uid']),
domain.get_user(self.domain_id, rdoc['uid']))
try:
pdoc = await problem.get(rdoc['domain_id'], rdoc['pid'])
except error.ProblemNotFoundError:
pdoc = {}
if show_status and 'judge_uid' in rdoc:
judge_udoc = await user.get_by_uid(rdoc['judge_uid'])
else:
judge_udoc = None
# check permission for visibility: hidden problem
if pdoc.get('hidden', False) and not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
pdoc = None
url_prefix = '/d/{}'.format(urllib.parse.quote(self.domain_id))
self.render('record_detail.html', rdoc=rdoc, udoc=udoc, dudoc=dudoc, pdoc=pdoc, tdoc=tdoc,
judge_udoc=judge_udoc, show_status=show_status,
socket_url=url_prefix + '/records/{}/conn'.format(rid)) # FIXME(twd2): magic
async def on_record_change(self, e):
rdoc = await record.get(objectid.ObjectId(e['value']),
record.PROJECTION_PUBLIC)
# check permission for visibility: contest
if rdoc['tid']:
now = datetime.datetime.utcnow()
tdoc = await contest.get(rdoc['domain_id'], rdoc['tid'])
if (not contest.RULES[tdoc['rule']].show_func(tdoc, now) and
(self.domain_id != tdoc['domain_id'] or
not self.has_perm(builtin.PERM_VIEW_CONTEST_HIDDEN_STATUS))):
return
# TODO(iceboy): join from event to improve performance?
# TODO(iceboy): projection.
udoc, pdoc = await asyncio.gather(
user.get_by_uid(rdoc['uid']),
problem.get(rdoc['domain_id'], rdoc['pid']))
# check permission for visibility: hidden problem
if pdoc.get('hidden', False) and (
pdoc['domain_id'] != self.domain_id
or not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)):
pdoc = None
self.send(html=self.render_html(
'record_main_tr.html', rdoc=rdoc, udoc=udoc, pdoc=pdoc))
async def get(self, *, tid: objectid.ObjectId, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(contest.get(self.domain_id, document.TYPE_CONTEST, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc, dudoc = await asyncio.gather(
contest.get_status(self.domain_id, document.TYPE_CONTEST, tdoc['doc_id'], self.user['_id']),
user.get_by_uid(tdoc['owner_uid']),
domain.get_user(domain_id=self.domain_id, uid=tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not self.is_done(tdoc):
if not attended:
raise error.ContestNotAttendedError(tdoc['doc_id'])
if not self.is_ongoing(tdoc):
raise error.ContestNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid, tdoc['doc_id'])
path_components = self.build_path(
(self.translate('contest_main'), self.reverse_url('contest_main')),
(tdoc['title'], self.reverse_url('contest_detail', tid=tid)),
(pdoc['title'], None))
self.render('problem_detail.html', tdoc=tdoc, pdoc=pdoc, tsdoc=tsdoc, udoc=udoc,
attended=attended, dudoc=dudoc,
page_title=pdoc['title'], path_components=path_components)
async def get(self, *, ctype: str, tid: objectid.ObjectId,
pid: document.convert_doc_id):
doc_type = constant.contest.CTYPE_TO_DOCTYPE[ctype]
uid = self.user['_id'] if self.has_priv(
builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, doc_type, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, doc_type, tdoc['doc_id'],
self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not attended:
if ctype == 'contest':
raise error.ContestNotAttendedError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if not self.is_ongoing(tdoc):
if ctype == 'contest':
raise error.ContestNotLiveError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotLiveError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
if self.can_show_record(tdoc):
rdocs = await record.get_user_in_problem_multi(uid, self.domain_id, pdoc['doc_id'], get_hidden=True) \
.sort([('_id', -1)]) \
.limit(10) \
.to_list()
else:
rdocs = []
if not self.prefer_json:
path_components = self.build_path(
(self.translate('page.contest_main.{0}.title'.format(ctype)),
self.reverse_url('contest_main', ctype=ctype)),
(tdoc['title'],
self.reverse_url('contest_detail', ctype=ctype, tid=tid)),
(pdoc['title'],
self.reverse_url(
'contest_detail_problem', ctype=ctype, tid=tid, pid=pid)),
(self.translate('page.contest_detail_problem_submit.{0}.title'.
format(ctype)), None))
languages = filter_language(pdoc.get('languages') or [])
default_lang = len(languages) and list(languages.keys())[0] or ''
self.render('problem_submit.html',
tdoc=tdoc,
pdoc=pdoc,
rdocs=rdocs,
tsdoc=tsdoc,
udoc=udoc,
attended=attended,
page_title=pdoc['title'],
path_components=path_components,
languages=languages,
default_lang=default_lang)
else:
self.json({'rdocs': rdocs})
