async def get(self, *, category: str, page: int = 1):
# TODO(iceboy): projection.
if not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
f = {'hidden': False}
else:
f = {}
query = ProblemCategoryHandler.build_query(category)
pdocs, ppcount, pcount = await pagination.paginate(problem.get_multi(domain_id=self.domain_id,
**query,
**f) \
.sort([('doc_id', 1)]),
page, self.PROBLEMS_PER_PAGE)
if self.has_priv(builtin.PRIV_USER_PROFILE):
# TODO(iceboy): projection.
psdict = await problem.get_dict_status(self.domain_id,
self.user['_id'],
(pdoc['doc_id']
for pdoc in pdocs))
else:
psdict = None
page_title = category or self.translate('(All Problems)')
path_components = self.build_path(
(self.translate('problem_main'), self.reverse_url('problem_main')),
(page_title, None))
await render_or_json_problem_list(self,
page=page,
ppcount=ppcount,
pcount=pcount,
pdocs=pdocs,
category=category,
psdict=psdict,
page_title=page_title,
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, *, page: int = 1):
# TODO(iceboy): projection.
if not self.has_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN):
f = {'hidden': False}
else:
f = {}
pdocs, ppcount, pcount = await pagination.paginate(problem.get_multi(domain_id=self.domain_id,
**f) \
.sort([('doc_id', 1)]),
page, self.PROBLEMS_PER_PAGE)
if self.has_priv(builtin.PRIV_USER_PROFILE):
# TODO(iceboy): projection.
psdict = await problem.get_dict_status(self.domain_id,
self.user['_id'],
(pdoc['doc_id']
for pdoc in pdocs))
else:
psdict = None
await render_or_json_problem_list(self,
page=page,
ppcount=ppcount,
pcount=pcount,
pdocs=pdocs,
category='',
psdict=psdict)
async def run(domain_id: str):
_logger.info('Clearing previous statuses')
await db.coll('document.status').update_many(
{'domain_id': domain_id, 'doc_type': document.TYPE_PROBLEM},
{'$unset': {'journal': '', 'rev': '', 'status': '', 'rid': '',
'num_submit': '', 'num_accept': ''}})
pdocs = problem.get_multi(domain_id=domain_id, fields={'_id': 1, 'doc_id': 1}).sort('doc_id', 1)
dudoc_factory = functools.partial(dict, num_submit=0, num_accept=0)
dudoc_updates = collections.defaultdict(dudoc_factory)
status_coll = db.coll('document.status')
async for pdoc in pdocs:
_logger.info('Problem {0}'.format(pdoc['doc_id']))
# TODO(twd2): ignore no effect statuses like system error, ...
rdocs = record.get_multi(domain_id=domain_id, pid=pdoc['doc_id'],
type=constant.record.TYPE_SUBMISSION,
fields={'_id': 1, 'uid': 1,
'status': 1, 'score': 1}).sort('_id', 1)
_logger.info('Reading records, counting numbers, updating statuses')
factory = functools.partial(dict, num_submit=0, num_accept=0, status=0, rid='')
psdocs = collections.defaultdict(factory)
pdoc_update = {'num_submit': 0, 'num_accept': 0}
async for rdoc in rdocs:
accept = True if rdoc['status'] == constant.record.STATUS_ACCEPTED else False
pdoc_update['num_submit'] += 1
psdocs[rdoc['uid']]['num_submit'] += 1
dudoc_updates[rdoc['uid']]['num_submit'] += 1
if psdocs[rdoc['uid']]['status'] != constant.record.STATUS_ACCEPTED:
psdocs[rdoc['uid']]['status'] = rdoc['status']
psdocs[rdoc['uid']]['rid'] = rdoc['_id']
if accept:
pdoc_update['num_accept'] += 1
dudoc_updates[rdoc['uid']]['num_accept'] += 1
status_bulk = status_coll.initialize_unordered_bulk_op()
execute = False
for uid, psdoc in psdocs.items():
execute = True
(status_bulk.find({'domain_id': domain_id, 'doc_type': document.TYPE_PROBLEM,
'doc_id': pdoc['doc_id'], 'uid': uid})
.upsert().update_one({'$set': {**psdoc}}))
if execute:
_logger.info('Committing')
await status_bulk.execute()
_logger.info('Updating problem')
await document.set(domain_id, document.TYPE_PROBLEM, pdoc['doc_id'], **pdoc_update)
# users' num_submit, num_accept
execute = False
user_coll = db.coll('domain.user')
user_bulk = user_coll.initialize_unordered_bulk_op()
_logger.info('Updating users')
for uid, dudoc_update in dudoc_updates.items():
execute = True
(user_bulk.find({'domain_id': domain_id, 'uid': uid})
.upsert().update_one({'$set': dudoc_update}))
if execute:
_logger.info('Committing')
await user_bulk.execute()
async def recalc(domain_id: str):
user_coll = db.Collection('domain.user')
await user_coll.update_many({'domain_id': domain_id},
{'$set': {
'rp': 0.0
}})
pdocs = problem.get_multi(domain_id=domain_id,
fields={
'_id': 1,
'doc_id': 1,
'num_accept': 1
}).sort('doc_id', 1)
dudoc_updates = {}
status_coll = db.Collection('document.status')
async for pdoc in pdocs:
_logger.info('Problem {0}'.format(pdoc['doc_id']))
psdocs = problem.get_multi_status(
domain_id=domain_id,
doc_id=pdoc['doc_id'],
status=constant.record.STATUS_ACCEPTED).sort('rid', 1)
order = 0
rp_func = get_rp_func(pdoc)
status_bulk = status_coll.initialize_unordered_bulk_op()
async for psdoc in psdocs:
order += 1
rp = rp_func(order)
status_bulk.find({
'_id': psdoc['_id']
}).update_one({'$set': {
'rp': rp
}})
if psdoc['uid'] not in dudoc_updates:
dudoc_updates[psdoc['uid']] = {'rp': rp}
else:
dudoc_updates[psdoc['uid']]['rp'] += rp
if order != pdoc['num_accept']:
_logger.warning('{0} != {1}'.format(order, pdoc['num_accept']))
_logger.warning(
'Problem {0} num_accept may be inconsistent.'.format(
pdoc['doc_id']))
if order > 0:
_logger.info('Committing')
await status_bulk.execute()
# users' rp
user_bulk = user_coll.initialize_unordered_bulk_op()
execute = False
_logger.info('Updating users')
for uid, dudoc_update in dudoc_updates.items():
execute = True
user_bulk.find({'domain_id': domain_id, 'uid': uid}) \
.upsert().update_one({'$set': dudoc_update})
if execute:
_logger.info('Committing')
await user_bulk.execute()
async def recalc(domain_id: str):
pdocs = problem.get_multi(domain_id=domain_id)
coll = db.Collection('document')
bulk = coll.initialize_unordered_bulk_op()
execute = False
_logger.info('Calculating')
async for pdoc in pdocs:
difficulty_algo = difficulty_altorithm(pdoc['num_submit'], pdoc['num_accept'])
difficulty = _get_difficulty(pdoc, difficulty_algo)
bulk.find({'_id': pdoc['_id']}) \
.update_one({'$set': {'difficulty': difficulty,
'difficulty_algo': difficulty_algo}})
execute = True
if execute:
_logger.info('Committing')
await bulk.execute()
async def recalc(domain_id: str):
pdocs = problem.get_multi(domain_id=domain_id)
coll = db.coll('document')
bulk = coll.initialize_unordered_bulk_op()
execute = False
_logger.info('Calculating')
async for pdoc in pdocs:
difficulty_algo = difficulty_altorithm(pdoc['num_submit'], pdoc['num_accept'])
difficulty = _get_difficulty(pdoc, difficulty_algo)
bulk.find({'_id': pdoc['_id']}) \
.update_one({'$set': {'difficulty': difficulty,
'difficulty_algo': difficulty_algo}})
execute = True
if execute:
_logger.info('Committing')
await bulk.execute()
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 recalc(domain_id: str):
user_coll = db.coll('domain.user')
await user_coll.update_many({'domain_id': domain_id}, {'$set': {'rp': 0.0}})
pdocs = problem.get_multi(domain_id=domain_id,
fields={'_id': 1, 'doc_id': 1, 'num_accept': 1}).sort('doc_id', 1)
dudoc_updates = {}
status_coll = db.coll('document.status')
async for pdoc in pdocs:
_logger.info('Problem {0}'.format(pdoc['doc_id']))
psdocs = problem.get_multi_status(domain_id=domain_id,
doc_id=pdoc['doc_id'],
status=constant.record.STATUS_ACCEPTED).sort('rid', 1)
order = 0
rp_func = get_rp_func(pdoc)
status_bulk = status_coll.initialize_unordered_bulk_op()
async for psdoc in psdocs:
order += 1
rp = rp_func(order)
status_bulk.find({'_id': psdoc['_id']}).update_one({'$set': {'rp': rp}})
if psdoc['uid'] not in dudoc_updates:
dudoc_updates[psdoc['uid']] = {'rp': rp}
else:
dudoc_updates[psdoc['uid']]['rp'] += rp
if order != pdoc['num_accept']:
_logger.warning('{0} != {1}'.format(order, pdoc['num_accept']))
_logger.warning('Problem {0} num_accept may be inconsistent.'.format(pdoc['doc_id']))
if order > 0:
_logger.info('Committing')
await status_bulk.execute()
# users' rp
user_bulk = user_coll.initialize_unordered_bulk_op()
execute = False
_logger.info('Updating users')
for uid, dudoc_update in dudoc_updates.items():
execute = True
user_bulk.find({'domain_id': domain_id, 'uid': uid}) \
.upsert().update_one({'$set': dudoc_update})
if execute:
_logger.info('Committing')
await user_bulk.execute()
async def run(domain_id: str):
_logger.info('Clearing previous statuses')
await db.Collection('document.status').update_many(
{
'domain_id': domain_id,
'doc_type': document.TYPE_PROBLEM
}, {
'$unset': {
'journal': '',
'rev': '',
'status': '',
'rid': '',
'num_submit': '',
'num_accept': ''
}
})
pdocs = problem.get_multi(domain_id=domain_id,
fields={
'_id': 1,
'doc_id': 1
}).sort('doc_id', 1)
dudoc_factory = functools.partial(dict, num_submit=0, num_accept=0)
dudoc_updates = collections.defaultdict(dudoc_factory)
status_coll = db.Collection('document.status')
async for pdoc in pdocs:
_logger.info('Problem {0}'.format(pdoc['doc_id']))
# TODO(twd2): ignore no effect statuses like system error, ...
rdocs = record.get_multi(domain_id=domain_id,
pid=pdoc['doc_id'],
type=constant.record.TYPE_SUBMISSION,
fields={
'_id': 1,
'uid': 1,
'status': 1,
'score': 1
}).sort('_id', 1)
_logger.info('Reading records, counting numbers, updating statuses')
factory = functools.partial(dict,
num_submit=0,
num_accept=0,
status=0,
rid='')
psdocs = collections.defaultdict(factory)
pdoc_update = {'num_submit': 0, 'num_accept': 0}
async for rdoc in rdocs:
accept = True if rdoc[
'status'] == constant.record.STATUS_ACCEPTED else False
pdoc_update['num_submit'] += 1
psdocs[rdoc['uid']]['num_submit'] += 1
dudoc_updates[rdoc['uid']]['num_submit'] += 1
if psdocs[
rdoc['uid']]['status'] != constant.record.STATUS_ACCEPTED:
psdocs[rdoc['uid']]['status'] = rdoc['status']
psdocs[rdoc['uid']]['rid'] = rdoc['_id']
if accept:
pdoc_update['num_accept'] += 1
dudoc_updates[rdoc['uid']]['num_accept'] += 1
status_bulk = status_coll.initialize_unordered_bulk_op()
execute = False
for uid, psdoc in psdocs.items():
execute = True
(status_bulk.find({
'domain_id': domain_id,
'doc_type': document.TYPE_PROBLEM,
'doc_id': pdoc['doc_id'],
'uid': uid
}).upsert().update_one({'$set': {
**psdoc
}}))
if execute:
_logger.info('Committing')
await status_bulk.execute()
_logger.info('Updating problem')
await document.set(domain_id, document.TYPE_PROBLEM, pdoc['doc_id'],
**pdoc_update)
# users' num_submit, num_accept
execute = False
user_coll = db.Collection('domain.user')
user_bulk = user_coll.initialize_unordered_bulk_op()
_logger.info('Updating users')
for uid, dudoc_update in dudoc_updates.items():
execute = True
(user_bulk.find({
'domain_id': domain_id,
'uid': uid
}).upsert().update_one({'$set': dudoc_update}))
if execute:
_logger.info('Committing')
await user_bulk.execute()
