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)