async def get(self, *, doc_type: int=None, doc_id: str, page: int=1):
if doc_type is None:
node_or_dtuple = doc_id
else:
node_or_dtuple = (doc_type, document.convert_doc_id(doc_id))
nodes, vnode = await discussion.get_nodes_and_vnode(self.domain_id, node_or_dtuple)
if not vnode:
raise error.DiscussionNodeNotFoundError(self.domain_id, node_or_dtuple)
if vnode['doc_type'] == document.TYPE_PROBLEM and vnode.get('hidden', False):
self.check_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)
# TODO(twd2): do more visibility check eg. contest
# TODO(iceboy): continuation based pagination.
ddocs, dpcount, _ = await pagination.paginate(
discussion.get_multi(self.domain_id,
parent_doc_type=vnode['doc_type'],
parent_doc_id=vnode['doc_id']),
page, self.DISCUSSIONS_PER_PAGE)
uids = set(ddoc['owner_uid'] for ddoc in ddocs)
if 'owner_uid' in vnode:
uids.add(vnode['owner_uid'])
udict, dudict = await asyncio.gather(user.get_dict(uids),
domain.get_dict_user_by_uid(self.domain_id, uids))
vndict = {node_or_dtuple: vnode}
vncontext = {} # TODO(twd2): eg. psdoc, tsdoc, ...
path_components = self.build_path(
(self.translate('discussion_main'), self.reverse_url('discussion_main')),
(vnode['title'], None))
self.render('discussion_main_or_node.html', discussion_nodes=nodes, vnode=vnode, ddocs=ddocs,
udict=udict, dudict=dudict, vndict=vndict, page=page, dpcount=dpcount, **vncontext,
path_components=path_components)
async def get(self, *, uid: int):
is_self_profile = self.has_priv(
builtin.PRIV_USER_PROFILE) and self.user['_id'] == uid
udoc = await user.get_by_uid(uid)
if not udoc:
raise error.UserNotFoundError(uid)
dudoc, sdoc = await asyncio.gather(
domain.get_user(self.domain_id, udoc['_id']),
token.get_most_recent_session_by_uid(udoc['_id']))
rdocs = record.get_multi(get_hidden=self.has_priv(
builtin.PRIV_VIEW_HIDDEN_RECORD),
uid=uid).sort([('_id', -1)])
rdocs = await rdocs.limit(10).to_list()
pdict = await problem.get_dict_multi_domain(
(rdoc['domain_id'], rdoc['pid']) for rdoc in rdocs)
# check hidden problem
if not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
f = {'hidden': False}
else:
f = {}
pdocs = problem.get_multi(domain_id=self.domain_id, owner_uid=uid,
**f).sort([('_id', -1)])
pcount = await pdocs.count()
pdocs = await pdocs.limit(10).to_list()
psdocs = problem.get_multi_solution_by_uid(self.domain_id, uid)
psdocs_hot = problem.get_multi_solution_by_uid(self.domain_id, uid)
pscount = await psdocs.count()
psdocs = await psdocs.limit(10).to_list()
psdocs_hot = await psdocs_hot.sort([('vote', -1), ('doc_id', -1)]
).limit(10).to_list()
if self.has_perm(builtin.PERM_VIEW_DISCUSSION):
ddocs = discussion.get_multi(self.domain_id, owner_uid=uid)
dcount = await ddocs.count()
ddocs = await ddocs.limit(10).to_list()
vndict = await discussion.get_dict_vnodes(
self.domain_id, map(discussion.node_id, ddocs))
else:
ddocs = []
vndict = {}
dcount = 0
self.render('user_detail.html',
is_self_profile=is_self_profile,
udoc=udoc,
dudoc=dudoc,
sdoc=sdoc,
rdocs=rdocs,
pdict=pdict,
pdocs=pdocs,
pcount=pcount,
psdocs=psdocs,
pscount=pscount,
psdocs_hot=psdocs_hot,
ddocs=ddocs,
dcount=dcount,
vndict=vndict)
async def get(self, *, doc_type: int=None, doc_id: str, page: int=1):
if doc_type is None:
node_or_dtuple = doc_id
else:
node_or_dtuple = (doc_type, document.convert_doc_id(doc_id))
nodes, vnode = await discussion.get_nodes_and_vnode(self.domain_id, node_or_dtuple)
if not vnode:
raise error.DiscussionNodeNotFoundError(self.domain_id, node_or_dtuple)
if vnode['doc_type'] == document.TYPE_PROBLEM and vnode.get('hidden', False):
self.check_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)
# TODO(twd2): do more visibility check eg. contest
# TODO(iceboy): continuation based pagination.
ddocs, dpcount, _ = await pagination.paginate(
discussion.get_multi(self.domain_id,
parent_doc_type=vnode['doc_type'],
parent_doc_id=vnode['doc_id']),
page, self.DISCUSSIONS_PER_PAGE)
uids = set(ddoc['owner_uid'] for ddoc in ddocs)
if 'owner_uid' in vnode:
uids.add(vnode['owner_uid'])
udict = await user.get_dict(uids)
vndict = {node_or_dtuple: vnode}
vncontext = {} # TODO(twd2): eg. psdoc, tsdoc, ...
path_components = self.build_path(
(self.translate('discussion_main'), self.reverse_url('discussion_main')),
(vnode['title'], None))
self.render('discussion_main_or_node.html', discussion_nodes=nodes, vnode=vnode, ddocs=ddocs,
udict=udict, vndict=vndict, page=page, dpcount=dpcount, **vncontext,
path_components=path_components)
async def get(self, *, page: int=1):
# TODO(iceboy): continuation based pagination.
nodes, (ddocs, dpcount, _) = await asyncio.gather(
discussion.get_nodes(self.domain_id),
# TODO(twd2): exclude problem/contest discussions?
pagination.paginate(discussion.get_multi(self.domain_id), page, self.DISCUSSIONS_PER_PAGE))
udict, vndict = await asyncio.gather(
user.get_dict(ddoc['owner_uid'] for ddoc in ddocs),
discussion.get_dict_vnodes(self.domain_id, map(discussion.node_id, ddocs)))
self.render('discussion_main_or_node.html', discussion_nodes=nodes, ddocs=ddocs,
udict=udict, vndict=vndict, page=page, dpcount=dpcount)
async def get(self, *, tid: objectid.ObjectId, page: int = 1):
# contest
tdoc = await contest.get(self.domain_id, tid)
tsdoc, pdict = await asyncio.gather(
contest.get_status(self.domain_id, tdoc['doc_id'],
self.user['_id']),
problem.get_dict(self.domain_id, tdoc['pids']))
psdict = dict()
rdict = dict()
if tsdoc:
attended = tsdoc.get('attend') == 1
for pdetail in tsdoc.get('detail', []):
psdict[pdetail['pid']] = pdetail
if self.can_show_record(tdoc):
rdict = await record.get_dict(
(psdoc['rid'] for psdoc in psdict.values()),
get_hidden=True)
else:
rdict = dict((psdoc['rid'], {
'_id': psdoc['rid']
}) for psdoc in psdict.values())
else:
attended = False
# discussion
ddocs, dpcount, dcount = await pagination.paginate(
discussion.get_multi(self.domain_id,
parent_doc_type=tdoc['doc_type'],
parent_doc_id=tdoc['doc_id']), page,
self.DISCUSSIONS_PER_PAGE)
uids = set(ddoc['owner_uid'] for ddoc in ddocs)
uids.add(tdoc['owner_uid'])
udict = await user.get_dict(uids)
dudict = await domain.get_dict_user_by_uid(domain_id=self.domain_id,
uids=uids)
path_components = self.build_path(
(self.translate('contest_main'), self.reverse_url('contest_main')),
(tdoc['title'], None))
self.render('contest_detail.html',
tdoc=tdoc,
tsdoc=tsdoc,
attended=attended,
udict=udict,
dudict=dudict,
pdict=pdict,
psdict=psdict,
rdict=rdict,
ddocs=ddocs,
page=page,
dpcount=dpcount,
dcount=dcount,
datetime_stamp=self.datetime_stamp,
page_title=tdoc['title'],
path_components=path_components)
async def get(self, *, page: int=1):
# TODO(iceboy): continuation based pagination.
nodes, (ddocs, dpcount, _) = await asyncio.gather(
discussion.get_nodes(self.domain_id),
# TODO(twd2): exclude problem/contest discussions?
pagination.paginate(discussion.get_multi(self.domain_id), page, self.DISCUSSIONS_PER_PAGE))
udict, dudict, vndict = await asyncio.gather(
user.get_dict(ddoc['owner_uid'] for ddoc in ddocs),
domain.get_dict_user_by_uid(domain_id=self.domain_id, uids=(ddoc['owner_uid'] for ddoc in ddocs)),
discussion.get_dict_vnodes(self.domain_id, map(discussion.node_id, ddocs)))
self.render('discussion_main_or_node.html', discussion_nodes=nodes, ddocs=ddocs,
udict=udict, dudict=dudict, vndict=vndict, page=page, dpcount=dpcount)
async def get(self, *, uid: int):
is_self_profile = self.has_priv(builtin.PRIV_USER_PROFILE) and self.user['_id'] == uid
udoc = await user.get_by_uid(uid)
if not udoc:
raise error.UserNotFoundError(uid)
dudoc, sdoc = await asyncio.gather(domain.get_user(self.domain_id, udoc['_id']),
token.get_most_recent_session_by_uid(udoc['_id']))
rdocs = record.get_multi(get_hidden=self.has_priv(builtin.PRIV_VIEW_HIDDEN_RECORD),
uid=uid).sort([('_id', -1)])
rdocs = await rdocs.limit(10).to_list()
pdict = await problem.get_dict_multi_domain((rdoc['domain_id'], rdoc['pid']) for rdoc in rdocs)
# check hidden problem
if not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
f = {'hidden': False}
else:
f = {}
pdocs = problem.get_multi(domain_id=self.domain_id, owner_uid=uid, **f).sort([('_id', -1)])
pcount = await pdocs.count()
pdocs = await pdocs.limit(10).to_list()
psdocs = problem.get_multi_solution_by_uid(self.domain_id, uid)
psdocs_hot = problem.get_multi_solution_by_uid(self.domain_id, uid)
pscount = await psdocs.count()
psdocs = await psdocs.limit(10).to_list()
psdocs_hot = await psdocs_hot.sort([('vote', -1), ('doc_id', -1)]).limit(10).to_list()
if self.has_perm(builtin.PERM_VIEW_DISCUSSION):
ddocs = discussion.get_multi(self.domain_id, owner_uid=uid)
dcount = await ddocs.count()
ddocs = await ddocs.limit(10).to_list()
vndict = await discussion.get_dict_vnodes(self.domain_id, map(discussion.node_id, ddocs))
else:
ddocs = []
vndict = {}
dcount = 0
self.render('user_detail.html', is_self_profile=is_self_profile,
udoc=udoc, dudoc=dudoc, sdoc=sdoc,
rdocs=rdocs, pdict=pdict, pdocs=pdocs, pcount=pcount,
psdocs=psdocs, pscount=pscount, psdocs_hot=psdocs_hot,
ddocs=ddocs, dcount=dcount, vndict=vndict)
async def get(self, *, uid: int):
is_self_profile = self.has_priv(
builtin.PRIV_USER_PROFILE) and self.user['_id'] == uid
udoc = await user.get_by_uid(uid)
if not udoc:
raise error.UserNotFoundError(uid)
dudoc, sdoc = await asyncio.gather(
domain.get_user(self.domain_id, udoc['_id']),
token.get_most_recent_session_by_uid(udoc['_id']))
email = self.get_udoc_setting(udoc, 'mail')
if email:
email = email.replace('@', random.choice([' [at] ', '#']))
bg = random.randint(1, 21)
rdocs = record.get_multi(get_hidden=self.has_priv(
builtin.PRIV_VIEW_HIDDEN_RECORD),
uid=uid).sort([('_id', -1)])
rdocs = await rdocs.limit(10).to_list(None)
# TODO(twd2): check status, eg. test, hidden problem, ...
pdocs = problem.get_multi(domain_id=self.domain_id,
owner_uid=uid).sort([('_id', -1)])
pcount = await pdocs.count()
pdocs = await pdocs.limit(10).to_list(None)
psdocs = problem.get_multi_solution_by_uid(self.domain_id, uid)
pscount = await psdocs.count()
psdocs = await psdocs.limit(10).to_list(None)
ddocs = discussion.get_multi(self.domain_id, owner_uid=uid)
dcount = await ddocs.count()
ddocs = await ddocs.limit(10).to_list(None)
self.render('user_detail.html',
is_self_profile=is_self_profile,
udoc=udoc,
dudoc=dudoc,
sdoc=sdoc,
email=email,
bg=bg,
rdocs=rdocs,
pdocs=pdocs,
pcount=pcount,
psdocs=psdocs,
pscount=pscount,
ddocs=ddocs,
dcount=dcount)
async def get(self, *, tid: objectid.ObjectId, page: int=1):
tdoc = await contest.get(self.domain_id, document.TYPE_CONTEST, tid)
tsdoc, pdict = await asyncio.gather(
contest.get_status(self.domain_id, document.TYPE_CONTEST, tdoc['doc_id'], self.user['_id']),
problem.get_dict(self.domain_id, tdoc['pids']))
psdict = dict()
rdict = dict()
if tsdoc:
attended = tsdoc.get('attend') == 1
for pdetail in tsdoc.get('detail', []):
psdict[pdetail['pid']] = pdetail
if self.can_show_record(tdoc):
rdict = await record.get_dict((psdoc['rid'] for psdoc in psdict.values()),
get_hidden=True)
else:
rdict = dict((psdoc['rid'], {'_id': psdoc['rid']}) for psdoc in psdict.values())
else:
attended = False
# discussion
ddocs, dpcount, dcount = await pagination.paginate(
discussion.get_multi(self.domain_id,
parent_doc_type=tdoc['doc_type'],
parent_doc_id=tdoc['doc_id']),
page, self.DISCUSSIONS_PER_PAGE)
uids = set(ddoc['owner_uid'] for ddoc in ddocs)
uids.add(tdoc['owner_uid'])
udict = await user.get_dict(uids)
dudict = await domain.get_dict_user_by_uid(domain_id=self.domain_id, uids=uids)
path_components = self.build_path(
(self.translate('contest_main'), self.reverse_url('contest_main')),
(tdoc['title'], None))
self.render('contest_detail.html', tdoc=tdoc, tsdoc=tsdoc, attended=attended, udict=udict,
dudict=dudict, pdict=pdict, psdict=psdict, rdict=rdict,
ddocs=ddocs, page=page, dpcount=dpcount, dcount=dcount,
datetime_stamp=self.datetime_stamp,
page_title=tdoc['title'], path_components=path_components)
