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 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_scoreboard(self, tid: objectid.ObjectId, is_export: bool = False): tdoc, tsdocs = await contest.get_and_list_status(self.domain_id, tid) if not self.can_show_scoreboard(tdoc): raise error.ContestScoreboardHiddenError(self.domain_id, tid) udict, pdict = await asyncio.gather( user.get_dict([tsdoc['uid'] for tsdoc in tsdocs]), problem.get_dict(self.domain_id, tdoc['pids'])) ranked_tsdocs = contest.RULES[tdoc['rule']].rank_func(tsdocs) rows = contest.RULES[tdoc['rule']].scoreboard_func( is_export, self.translate, tdoc, ranked_tsdocs, udict, pdict) return tdoc, rows
async def get(self, *, tid: objectid.ObjectId): tdoc, tsdocs = await contest.get_and_list_status(self.domain_id, tid) if (not contest.RULES[tdoc['rule']].show_func(tdoc, self.now) and not self.has_perm(builtin.PERM_VIEW_CONTEST_HIDDEN_STATUS)): raise error.ContestStatusHiddenError() udict, pdict = await asyncio.gather(user.get_dict([tsdoc['uid'] for tsdoc in tsdocs]), problem.get_dict(self.domain_id, tdoc['pids'])) ranked_tsdocs = contest.RULES[tdoc['rule']].rank_func(tsdocs) path_components = self.build_path( (self.translate('contest_main'), self.reverse_url('contest_main')), (tdoc['title'], self.reverse_url('contest_detail', tid=tdoc['doc_id'])), (self.translate('contest_status'), None)) self.render('contest_status.html', tdoc=tdoc, ranked_tsdocs=ranked_tsdocs, dict=dict, udict=udict, pdict=pdict, 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 get_scoreboard(self, doc_type: int, tid: objectid.ObjectId, is_export: bool=False): if doc_type not in [document.TYPE_CONTEST, document.TYPE_HOMEWORK]: raise error.InvalidArgumentError('doc_type') tdoc, tsdocs = await get_and_list_status(self.domain_id, doc_type, tid) if not self.can_show_scoreboard(tdoc): if doc_type == document.TYPE_CONTEST: raise error.ContestScoreboardHiddenError(self.domain_id, tid) elif doc_type == document.TYPE_HOMEWORK: raise error.HomeworkScoreboardHiddenError(self.domain_id, tid) udict, dudict, pdict = await asyncio.gather( user.get_dict([tsdoc['uid'] for tsdoc in tsdocs]), domain.get_dict_user_by_uid(self.domain_id, [tsdoc['uid'] for tsdoc in tsdocs]), problem.get_dict(self.domain_id, tdoc['pids'])) ranked_tsdocs = RULES[tdoc['rule']].rank_func(tsdocs) rows = RULES[tdoc['rule']].scoreboard_func(is_export, self.translate, tdoc, ranked_tsdocs, udict, dudict, pdict) return tdoc, rows, udict
async def get_scoreboard(self, doc_type: int, tid: objectid.ObjectId, is_export: bool=False): if doc_type not in [document.TYPE_CONTEST, document.TYPE_HOMEWORK]: raise error.InvalidArgumentError('doc_type') tdoc, tsdocs = await get_and_list_status(self.domain_id, doc_type, tid) if not self.can_show_scoreboard(tdoc): if doc_type == document.TYPE_CONTEST: raise error.ContestScoreboardHiddenError(self.domain_id, tid) elif doc_type == document.TYPE_HOMEWORK: raise error.HomeworkScoreboardHiddenError(self.domain_id, tid) udict, dudict, pdict = await asyncio.gather( user.get_dict([tsdoc['uid'] for tsdoc in tsdocs]), domain.get_dict_user_by_uid(self.domain_id, [tsdoc['uid'] for tsdoc in tsdocs]), problem.get_dict(self.domain_id, tdoc['pids'])) ranked_tsdocs = RULES[tdoc['rule']].rank_func(tsdocs) rows = RULES[tdoc['rule']].scoreboard_func(is_export, self.translate, tdoc, ranked_tsdocs, udict, dudict, pdict) return tdoc, rows, udict
async def get(self, *, tid: objectid.ObjectId, ext: str): get_content = { 'csv': self.get_csv_content, 'html': self.get_html_content, } if ext not in get_content: raise error.ValidationError('ext') tdoc, tsdocs = await contest.get_and_list_status(self.domain_id, tid) if (not contest.RULES[tdoc['rule']].show_func(tdoc, self.now) and not self.has_perm(builtin.PERM_VIEW_CONTEST_HIDDEN_STATUS)): raise error.ContestStatusHiddenError() udict, pdict = await asyncio.gather(user.get_dict([tsdoc['uid'] for tsdoc in tsdocs]), problem.get_dict(self.domain_id, tdoc['pids'])) ranked_tsdocs = contest.RULES[tdoc['rule']].rank_func(tsdocs) get_status = { constant.contest.RULE_ACM: self.get_acm_status, constant.contest.RULE_OI: self.get_oi_status, } rows = get_status[tdoc['rule']](tdoc, ranked_tsdocs, udict, pdict) data = get_content[ext](rows) file_name = tdoc['title'] for char in '/<>:\"\'\\|?* ': file_name = file_name.replace(char, '') await self.binary(data, file_name='{0}.{1}'.format(file_name, ext))
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)
async def get_scoreboard(self, tid: objectid.ObjectId, is_export: bool = False): tdoc, tsdocs = await contest.get_and_list_status(self.domain_id, tid) if not self.can_show_scoreboard(tdoc): raise error.ContestScoreboardHiddenError(self.domain_id, tid) udict, dudict, pdict = await asyncio.gather( user.get_dict([tsdoc['uid'] for tsdoc in tsdocs]), domain.get_dict_user_by_uid(self.domain_id, [tsdoc['uid'] for tsdoc in tsdocs]), problem.get_dict(self.domain_id, tdoc['pids'])) for pkey in pdict: p = pdict[pkey] p['dataUploadTime'] = await fs.get_datetime(p['data']) #_logger.error(pdict) #_logger.error(tsdocs) for ts in tsdocs: #_logger.error(type(ts)) if not 'journal' in ts: continue journal = ts['journal'] ts['submit_count_highest'] = {} ts['submit_count_total'] = {} ts['highest_score'] = {} ts['highest_score_rid'] = {} ts['highest_penalized_score'] = {} ts['highest_penalized_score_rid'] = {} # Initialize counter to 0 for p in pdict: ts['submit_count_total'][p] = 0 ts['highest_score'][p] = 0 ts['highest_penalized_score'][p] = 0 # Journal records all submissions related to the contest jdocs = [] for j in journal: jdocs.append(await record.get(j['rid'])) #jdocs = sorted(jdocs, key=lambda k: k['judge_at']) #if ts['uid'] == -3: # _logger.error(jdocs) for jdoc in jdocs: p = jdoc['pid'] #_logger.error(p) #_logger.error(jdoc['_id']) #_logger.error(pdict[p]['dataUploadTime']) #_logger.error(jdoc['judge_at']) # If judge time is after data upload time, add the counter if 'judge_at' in jdoc: if jdoc['judge_at'] >= pdict[p]['dataUploadTime']: #_logger.error('gg') penalized_score = jdoc[ 'score'] - ts['submit_count_total'][ p] * builtin.RULE_PENALTY_SCORE_PER_SUBMISSION if penalized_score < 0: penalized_score = 0 ts['submit_count_total'][p] += 1 if penalized_score > ts['highest_penalized_score'][p]: ts['highest_penalized_score'][p] = penalized_score ts['highest_penalized_score_rid'][p] = jdoc['_id'] if ts['highest_score'][p] < jdoc['score']: #if ts['uid'] == -3: # _logger.error(highest) # _logger.error(jdoc['score']) ts['highest_score'][p] = jdoc['score'] ts['submit_count_highest'][p] = ts[ 'submit_count_total'][p] ts['highest_score_rid'][p] = jdoc['_id'] sum_score = 0 for p in pdict: sum_score += ts['highest_penalized_score'][p] ts['sum_score'] = sum_score tsdocs = sorted(tsdocs, key=lambda k: k.get('sum_score', 0), reverse=True) #_logger.error([ts['highest_penalized_score'] for ts in tsdocs]) ranked_tsdocs = contest.RULES[tdoc['rule']].rank_func(tsdocs) rows = contest.RULES[tdoc['rule']].scoreboard_func( is_export, self.translate, tdoc, ranked_tsdocs, udict, dudict, pdict) #_logger.error(tdoc) return tdoc, rows, udict