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 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 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 check_password_by_uname(uname: str, password: str, auto_upgrade: bool=False):
"""Check password. Returns doc or None."""
doc = await get_by_uname(uname, PROJECTION_ALL)
if not doc:
raise error.UserNotFoundError(uname)
if pwhash.check(password, doc['salt'], doc['hash']):
if auto_upgrade and pwhash.need_upgrade(doc['hash']) \
and validator.is_password(password):
await set_password(doc['_id'], password)
return doc
async def post(self, *, mail: str):
validator.check_mail(mail)
udoc = await user.get_by_mail(mail)
if not udoc:
raise error.UserNotFoundError(mail)
rid, _ = await token.add(token.TYPE_LOSTPASS,
options.lostpass_token_expire_seconds,
uid=udoc['_id'])
await self.send_mail(mail, 'Lost Password', 'user_lostpass_mail.html',
url=self.reverse_url('user_lostpass_with_code', code=rid),
uname=udoc['uname'])
self.render('user_lostpass_mail_sent.html')
async def post_send_message(self, *, uid: int, content: str):
udoc = await user.get_by_uid(uid, user.PROJECTION_PUBLIC)
if not udoc:
raise error.UserNotFoundError(uid)
mdoc = await message.add(self.user['_id'], udoc['_id'], content)
# TODO(twd2): improve here:
# projection
sender_udoc = await user.get_by_uid(self.user['_id'], user.PROJECTION_PUBLIC)
mdoc['sender_udoc'] = sender_udoc
self.modify_udoc(mdoc, 'sender_udoc')
mdoc['sendee_udoc'] = udoc
self.modify_udoc(mdoc, 'sendee_udoc')
if self.user['_id'] != uid:
await bus.publish('message_received-' + str(uid), {'type': 'new', 'data': mdoc})
self.json_or_redirect(self.url, mdoc=mdoc)
async def get_filter_query(self, uid_or_name, pid, tid):
query = dict()
if uid_or_name:
try:
query['uid'] = int(uid_or_name)
except ValueError:
udoc = await user.get_by_uname(uid_or_name)
if not udoc:
raise error.UserNotFoundError(uid_or_name) from None
query['uid'] = udoc['_id']
if pid or tid:
query['domain_id'] = self.domain_id
if pid:
query['pid'] = document.convert_doc_id(pid)
if tid:
query['tid'] = document.convert_doc_id(tid)
return query
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, *, uid: int):
udoc = await user.get_by_uid(uid)
if not udoc:
raise error.UserNotFoundError(uid)
sdoc = await token.get_most_recent_session_by_uid(udoc['_id'])
self.render('user_detail.html', udoc=udoc, sdoc=sdoc)
async def post_send_message(self, *, uid: int, content: str):
udoc = await user.get_by_uid(uid)
if not udoc:
raise error.UserNotFoundError(uid)
await message.add(self.user['_id'], udoc['_id'], content)
self.json_or_redirect(self.referer_or_main)
async def get(self,
*,
uid_or_name: str = '',
pid: str = '',
tid: str = ''):
query = {}
if uid_or_name:
try:
query['uid'] = int(uid_or_name)
except ValueError:
udoc = await user.get_by_uname(uid_or_name)
if not udoc:
raise error.UserNotFoundError(uid_or_name) from None
query['uid'] = udoc['_id']
if pid:
pid = document.convert_doc_id(pid)
query['domain_id'] = self.domain_id
query['pid'] = pid
if tid:
tid = document.convert_doc_id(tid)
query['domain_id'] = self.domain_id
query['tid'] = tid
# TODO(iceboy): projection, pagination.
rdocs = await record.get_all_multi(
**query,
get_hidden=self.has_priv(builtin.PRIV_VIEW_HIDDEN_RECORD)).sort([
('_id', -1)
]).limit(50).to_list(None)
# TODO(iceboy): projection.
udict, pdict = await asyncio.gather(
user.get_dict(rdoc['uid'] for rdoc in rdocs),
problem.get_dict_multi_domain(
(rdoc['domain_id'], rdoc['pid']) for rdoc in rdocs))
# statistics
statistics = None
if self.has_priv(builtin.PRIV_VIEW_JUDGE_STATISTICS):
ts = calendar.timegm(datetime.datetime.utcnow().utctimetuple())
day_count, week_count, month_count, year_count, rcount = await asyncio.gather(
record.get_count(
objectid.ObjectId(
struct.pack('>i', ts - 24 * 3600) +
struct.pack('b', -1) * 8)),
record.get_count(
objectid.ObjectId(
struct.pack('>i', ts - 7 * 24 * 3600) +
struct.pack('b', -1) * 8)),
record.get_count(
objectid.ObjectId(
struct.pack('>i', ts - 30 * 24 * 3600) +
struct.pack('b', -1) * 8)),
record.get_count(
objectid.ObjectId(
struct.pack('>i', ts - int(365.2425 * 24 * 3600)) +
struct.pack('b', -1) * 8)), record.get_count())
statistics = {
'day': day_count,
'week': week_count,
'month': month_count,
'year': year_count,
'total': rcount
}
self.render('record_main.html',
rdocs=rdocs,
udict=udict,
pdict=pdict,
statistics=statistics,
filter_uid_or_name=uid_or_name,
filter_pid=pid,
filter_tid=tid)
