async def get(self, *, tid: objectid.ObjectId,
pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(
builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, document.TYPE_HOMEWORK, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc, dudoc = await asyncio.gather(
contest.get_status(self.domain_id, document.TYPE_HOMEWORK,
tdoc['doc_id'], self.user['_id']),
user.get_by_uid(tdoc['owner_uid']),
domain.get_user(domain_id=self.domain_id, uid=tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not self.is_done(tdoc):
if not attended:
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
if not self.is_ongoing(tdoc):
raise error.HomeworkNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
path_components = self.build_path(
(self.translate('homework_main'),
self.reverse_url('homework_main')),
(tdoc['title'], self.reverse_url('homework_detail', tid=tid)),
(pdoc['title'], None))
self.render('problem_detail.html',
tdoc=tdoc,
pdoc=pdoc,
tsdoc=tsdoc,
udoc=udoc,
attended=attended,
dudoc=dudoc,
page_title=pdoc['title'],
path_components=path_components)
async def post(self, *, tid: objectid.ObjectId,
pid: document.convert_doc_id, lang: str, code: str):
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, document.TYPE_HOMEWORK, tid),
problem.get(self.domain_id, pid))
tsdoc = await contest.get_status(self.domain_id,
document.TYPE_HOMEWORK,
tdoc['doc_id'], self.user['_id'])
if not tsdoc or tsdoc.get('attend') != 1:
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
if not self.is_ongoing(tdoc):
raise error.HomeworkNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
rid = await record.add(self.domain_id,
pdoc['doc_id'],
constant.record.TYPE_SUBMISSION,
self.user['_id'],
lang,
code,
ttype=document.TYPE_HOMEWORK,
tid=tdoc['doc_id'],
hidden=True)
await contest.update_status(self.domain_id, document.TYPE_HOMEWORK,
tdoc['doc_id'], self.user['_id'], rid,
pdoc['doc_id'], False, 0)
if not self.can_show_record(tdoc):
self.json_or_redirect(
self.reverse_url('homework_detail', tid=tdoc['doc_id']))
else:
self.json_or_redirect(self.reverse_url('record_detail', rid=rid))
async def get(self, *, tid: objectid.ObjectId, pid: document.convert_doc_id):
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(contest.get(self.domain_id, document.TYPE_HOMEWORK, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, document.TYPE_HOMEWORK, tdoc['doc_id'], self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not attended:
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
if not self.is_ongoing(tdoc):
raise error.HomeworkNotLiveError(tdoc['doc_id'])
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid, tdoc['doc_id'])
if self.can_show_record(tdoc):
rdocs = await record.get_user_in_problem_multi(uid, self.domain_id, pdoc['doc_id'], get_hidden=True) \
.sort([('_id', -1)]) \
.limit(10) \
.to_list()
else:
rdocs = []
if not self.prefer_json:
path_components = self.build_path(
(self.translate('homework_main'), self.reverse_url('homework_main')),
(tdoc['title'], self.reverse_url('homework_detail', tid=tid)),
(pdoc['title'], self.reverse_url('homework_detail_problem', tid=tid, pid=pid)),
(self.translate('homework_detail_problem_submit'), None))
self.render('problem_submit.html', tdoc=tdoc, pdoc=pdoc, rdocs=rdocs,
tsdoc=tsdoc, udoc=udoc, attended=attended,
page_title=pdoc['title'], path_components=path_components)
else:
self.json({'rdocs': rdocs})
async def post_attend(self, *, tid: objectid.ObjectId):
tdoc = await contest.get(self.domain_id, document.TYPE_HOMEWORK, tid)
if self.is_done(tdoc):
raise error.HomeworkNotLiveError(tdoc['doc_id'])
await contest.attend(self.domain_id, document.TYPE_HOMEWORK,
tdoc['doc_id'], self.user['_id'])
self.json_or_redirect(self.url)
async def post(self, *, ctype: str, tid: objectid.ObjectId,
pid: document.convert_doc_id, lang: str,
code: objectid.ObjectId):
doc_type = constant.contest.CTYPE_TO_DOCTYPE[ctype]
# TODO(iceboy): rate limit base on ip.
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, doc_type, tid),
problem.get(self.domain_id, pid))
tsdoc = await contest.get_status(self.domain_id, doc_type,
tdoc['doc_id'], self.user['_id'])
if not tsdoc or tsdoc.get('attend') != 1:
if ctype == 'contest':
raise error.ContestNotAttendedError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if not self.is_ongoing(tdoc):
if ctype == 'contest':
raise error.ContestNotLiveError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotLiveError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
# TODO(tc-imba): only constant.record.CODE_TYPE_TAR is supported now
rid = await record.add(self.domain_id,
pdoc['doc_id'],
constant.record.TYPE_SUBMISSION,
self.user['_id'],
lang,
code,
tid=tdoc['doc_id'],
hidden=False,
code_type=constant.record.CODE_TYPE_TAR)
await contest.update_status(self.domain_id, tdoc['doc_id'],
self.user['_id'], rid, pdoc['doc_id'],
False, 0)
if not self.can_show_record(tdoc):
self.json_or_redirect(
self.reverse_url('contest_detail',
ctype=ctype,
tid=tdoc['doc_id']))
else:
self.json_or_redirect(self.reverse_url('record_detail', rid=rid))
async def get(self, *, ctype: str, tid: objectid.ObjectId,
pid: document.convert_doc_id):
doc_type = constant.contest.CTYPE_TO_DOCTYPE[ctype]
uid = self.user['_id'] if self.has_priv(
builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, doc_type, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, doc_type, tdoc['doc_id'],
self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not self.is_finished(tdoc):
if not attended:
if ctype == 'contest':
raise error.ContestNotAttendedError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if not self.is_ongoing(tdoc):
if ctype == 'contest':
raise error.ContestNotLiveError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotLiveError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
path_components = self.build_path(
(self.translate('page.contest_main.{0}.title'.format(ctype)),
self.reverse_url('contest_main', ctype=ctype)),
(tdoc['title'],
self.reverse_url('contest_detail', ctype=ctype, tid=tid)),
(pdoc['title'], None))
self.render('problem_detail.html',
tdoc=tdoc,
pdoc=pdoc,
tsdoc=tsdoc,
udoc=udoc,
attended=attended,
page_title=pdoc['title'],
path_components=path_components)
async def post(self, *, rid: str):
data = await self.request.post()
report = data['report']
code = data['code']
# 既没有报告，也没有代码
if not (hasattr(report, 'file') or hasattr(code, 'file')):
raise error.FileNotFoundError()
has_report = False
has_code = False
if hasattr(report, 'file'):
has_report = True
if hasattr(code, 'file'):
has_code = True
if has_report:
report_data = report.file
report_name = report.filename
report_extension = report_name.split(".")[-1]
if has_code:
code_data = code.file
code_name = code.filename
code_extension = code_name.split('.')[-1]
# def check_file_type(extension):
# if extension not in ['pdf', 'doc', 'docx']:
# raise error.FileTypeNotAllowedError(extension)
if has_report:
if report_extension not in ['pdf', 'doc', 'docx']:
raise error.ReportFileTypeNotAllowedError(report_extension)
if has_code:
if code_extension not in ['zip']:
raise error.CodeFileTypeNotAllowedError(code_extension)
uid = self.user['_id']
shanghai = pytz.timezone('Asia/Shanghai')
upload_time = datetime.datetime.utcnow().astimezone(shanghai)
student = mdb.user.find_one({"_id": uid})
rid = objectid.ObjectId(rid)
this_report = mdb.report.find_one({"_id": rid})
report_id = this_report['_id']
report_deadline = pytz.utc.localize(
this_report['end_at']).astimezone(shanghai)
print(upload_time)
print(report_deadline)
if upload_time > report_deadline:
raise error.HomeworkNotLiveError()
# 数据结构课设的 course_id 等于 3
if has_report:
if file_rename(3, 'report', student, this_report,
report_extension) is not None:
report_name = file_rename(3, 'report', student, this_report,
report_extension)
if has_code:
if file_rename(3, 'code', student, this_report,
code_extension) is not None:
code_name = file_rename(3, 'code', student, this_report,
code_extension)
ureport = mdb.ureport.find_one({
'user_id': uid,
'report_id': report_id
})
pdoc = None
if ureport:
# update report or code
if has_report:
try:
os.unlink('data/%s' % ureport['report_data'])
except FileNotFoundError as e:
pass
pdoc = mdb.ureport.update_one(
{
'user_id': uid,
'report_id': report_id
}, {
"$set": {
"report_data": report_name,
"upload_time": upload_time
}
})
if has_code:
try:
os.unlink('data/%s' % ureport['code_data'])
except FileNotFoundError as e:
pass
pdoc = mdb.ureport.update_one(
{
'user_id': uid,
'report_id': report_id
}, {
"$set": {
"code_data": code_name,
"upload_time": upload_time
}
})
else:
# create new report or code
if not has_report:
report_name = None
if not has_code:
code_name = None
pdoc = mdb.ureport.insert_one({
'_id': objectid.ObjectId(),
'user_id': uid,
'report_id': report_id,
'report_data': report_name,
'code_data': code_name,
'upload_time': upload_time
})
if has_report:
with open('data/%s' % report_name, 'wb') as f:
f.write(report_data.read())
if has_code:
with open('data/%s' % code_name, 'wb') as f:
f.write(code_data.read())
# if report.report_rename(student, report) is not None:
# file_name = report.report_rename(student, report)
# ureport = mdb.find_one({'user_id': uid, 'report_id': report_id})
# print(file_name)
# if ureport and ureport['data'] is objectid.ObjectId:
# await fs.unlink(ureport['data'])
# pdoc = await problem.get(self.domain_id, pid)
# if not self.own(pdoc, builtin.PERM_EDIT_PROBLEM_SELF):
# self.check_perm(builtin.PERM_EDIT_PROBLEM)
# if (not self.own(pdoc, builtin.PERM_READ_PROBLEM_DATA_SELF)
# and not self.has_perm(builtin.PERM_READ_PROBLEM_DATA)):
# self.check_priv(builtin.PRIV_READ_PROBLEM_DATA)
# if pdoc.get('data') and type(pdoc['data']) is objectid.ObjectId:
# await fs.unlink(pdoc['data'])
# await problem.set_data(self.domain_id, pid, file)
self.json_or_redirect(self.reverse_url('report_detail', rid=rid))
async def post(self, *, rid: str):
data = await self.request.post()
file = data.get('file')
file_data = file.file
file_name = file.filename
file_extension = file_name.split(".")[-1]
def check_file_type(extension):
if extension not in ['pdf', 'doc', 'docx']:
raise error.FileTypeNotAllowedError(extension)
check_file_type(file_extension)
uid = self.user['_id']
upload_time = pytz.utc.localize(datetime.datetime.now()).astimezone(self.timezone)
student = mdb.user.find_one({"_id": uid})
rid = objectid.ObjectId(rid)
this_report = mdb.report.find_one({"_id": rid})
report_id = this_report['_id']
report_deadline = pytz.utc.localize(this_report['end_at']).astimezone(self.timezone)
if upload_time > report_deadline:
raise error.HomeworkNotLiveError()
if report_rename(student, this_report, file_extension) is not None:
file_name = report_rename(student, this_report, file_extension)
ureport = mdb.ureport.find_one({'user_id': uid, 'report_id': report_id})
pdoc = None
if ureport:
try:
os.unlink('data/%s' % ureport['data'])
except FileNotFoundError as e:
pass
pdoc = mdb.ureport.update_one({'user_id': uid, 'report_id': report_id}, {"$set": {"data": file_name, "upload_time": upload_time}})
else:
pdoc = mdb.ureport.insert_one({
'_id': objectid.ObjectId(),
'user_id': uid,
'report_id': report_id,
'data': file_name,
'upload_time': upload_time})
buffer = io.BytesIO(file_data.read())
async with AIOFile('data/%s' % file_name, 'wb') as fb:
await fb.write(buffer.getvalue())
# if report.report_rename(student, report) is not None:
# file_name = report.report_rename(student, report)
# ureport = mdb.find_one({'user_id': uid, 'report_id': report_id})
# print(file_name)
# if ureport and ureport['data'] is objectid.ObjectId:
# await fs.unlink(ureport['data'])
# pdoc = await problem.get(self.domain_id, pid)
# if not self.own(pdoc, builtin.PERM_EDIT_PROBLEM_SELF):
# self.check_perm(builtin.PERM_EDIT_PROBLEM)
# if (not self.own(pdoc, builtin.PERM_READ_PROBLEM_DATA_SELF)
# and not self.has_perm(builtin.PERM_READ_PROBLEM_DATA)):
# self.check_priv(builtin.PRIV_READ_PROBLEM_DATA)
# if pdoc.get('data') and type(pdoc['data']) is objectid.ObjectId:
# await fs.unlink(pdoc['data'])
# await problem.set_data(self.domain_id, pid, file)
self.json_or_redirect(self.reverse_url('report_detail', rid=rid))
async def get(self, *, ctype: str, tid: objectid.ObjectId,
pid: document.convert_doc_id):
doc_type = constant.contest.CTYPE_TO_DOCTYPE[ctype]
uid = self.user['_id'] if self.has_priv(
builtin.PRIV_USER_PROFILE) else None
tdoc, pdoc = await asyncio.gather(
contest.get(self.domain_id, doc_type, tid),
problem.get(self.domain_id, pid, uid))
tsdoc, udoc = await asyncio.gather(
contest.get_status(self.domain_id, doc_type, tdoc['doc_id'],
self.user['_id']),
user.get_by_uid(tdoc['owner_uid']))
attended = tsdoc and tsdoc.get('attend') == 1
if not attended:
if ctype == 'contest':
raise error.ContestNotAttendedError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotAttendedError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if not self.is_ongoing(tdoc):
if ctype == 'contest':
raise error.ContestNotLiveError(tdoc['doc_id'])
elif ctype == 'homework':
raise error.HomeworkNotLiveError(tdoc['doc_id'])
else:
raise error.InvalidArgumentError('ctype')
if pid not in tdoc['pids']:
raise error.ProblemNotFoundError(self.domain_id, pid,
tdoc['doc_id'])
if self.can_show_record(tdoc):
rdocs = await record.get_user_in_problem_multi(uid, self.domain_id, pdoc['doc_id'], get_hidden=True) \
.sort([('_id', -1)]) \
.limit(10) \
.to_list()
else:
rdocs = []
if not self.prefer_json:
path_components = self.build_path(
(self.translate('page.contest_main.{0}.title'.format(ctype)),
self.reverse_url('contest_main', ctype=ctype)),
(tdoc['title'],
self.reverse_url('contest_detail', ctype=ctype, tid=tid)),
(pdoc['title'],
self.reverse_url(
'contest_detail_problem', ctype=ctype, tid=tid, pid=pid)),
(self.translate('page.contest_detail_problem_submit.{0}.title'.
format(ctype)), None))
languages = filter_language(pdoc.get('languages') or [])
default_lang = len(languages) and list(languages.keys())[0] or ''
self.render('problem_submit.html',
tdoc=tdoc,
pdoc=pdoc,
rdocs=rdocs,
tsdoc=tsdoc,
udoc=udoc,
attended=attended,
page_title=pdoc['title'],
path_components=path_components,
languages=languages,
default_lang=default_lang)
else:
self.json({'rdocs': rdocs})