|
|
|
const
|
|
|
|
fs = require('fs'),
|
|
|
|
paginate = require('../lib/paginate'),
|
|
|
|
validator = require('../lib/validator'),
|
|
|
|
problem = require('../model/problem'),
|
|
|
|
record = require('../model/record'),
|
|
|
|
user = require('../model/user'),
|
|
|
|
solution = require('../model/solution'),
|
|
|
|
system = require('../model/system'),
|
|
|
|
{ Route, Handler } = require('../service/server'),
|
|
|
|
gridfs = require('../service/gridfs'),
|
|
|
|
queue = require('../service/queue'),
|
|
|
|
{ NoProblemError, ProblemDataNotFoundError, BadRequestError,
|
|
|
|
SolutionNotFoundError } = require('../error'),
|
|
|
|
{ constants } = require('../options'),
|
|
|
|
{ PERM_VIEW_PROBLEM, PERM_VIEW_PROBLEM_HIDDEN, PERM_SUBMIT_PROBLEM,
|
|
|
|
PERM_CREATE_PROBLEM, PERM_READ_PROBLEM_DATA, PERM_EDIT_PROBLEM,
|
|
|
|
PERM_JUDGE, PERM_VIEW_PROBLEM_SOLUTION, PERM_CREATE_PROBLEM_SOLUTION,
|
|
|
|
PERM_EDIT_PROBLEM_SOLUTION, PERM_DELETE_PROBLEM_SOLUTION, PERM_EDIT_PROBLEM_SOLUTION_REPLY,
|
|
|
|
PERM_REPLY_PROBLEM_SOLUTION } = require('../permission');
|
|
|
|
|
|
|
|
queue.assert('judge');
|
|
|
|
|
|
|
|
class ProblemHandler extends Handler {
|
|
|
|
async _prepare() {
|
|
|
|
this.checkPerm(PERM_VIEW_PROBLEM);
|
|
|
|
}
|
|
|
|
async get({ page = 1, category = null }) {
|
|
|
|
this.response.template = 'problem_main.html';
|
|
|
|
let q = {};
|
|
|
|
if (category) q.category = category;
|
|
|
|
if (!this.user.hasPerm(PERM_VIEW_PROBLEM_HIDDEN)) q.hidden = false;
|
|
|
|
let pdocs = await problem.getMany(q, { pid: 1 }, page, constants.PROBLEM_PER_PAGE);
|
|
|
|
this.response.body = {
|
|
|
|
path: [
|
|
|
|
['Hydro', '/'],
|
|
|
|
['problem_main', null]
|
|
|
|
],
|
|
|
|
page, pdocs, category: ''
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemRandomHandler extends ProblemHandler {
|
|
|
|
async get() {
|
|
|
|
let q = {};
|
|
|
|
if (!this.user.hasPerm(PERM_VIEW_PROBLEM_HIDDEN)) q.hidden = false;
|
|
|
|
let pid = await problem.random(q);
|
|
|
|
if (!pid) throw new NoProblemError();
|
|
|
|
this.response.body = { pid };
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemDetailHandler extends ProblemHandler {
|
|
|
|
constructor(ctx) {
|
|
|
|
super(ctx);
|
|
|
|
this.uid = ctx.state.user._id;
|
|
|
|
this.pid = ctx.params.pid;
|
|
|
|
this.response.template = 'problem_detail.html';
|
|
|
|
}
|
|
|
|
async _prepare() {
|
|
|
|
if (this.pid) this.pdoc = await problem.get(this);
|
|
|
|
if (this.pdoc.hidden && this.pdoc.owner != this.uid) this.checkPerm(PERM_VIEW_PROBLEM_HIDDEN);
|
|
|
|
if (this.pdoc) this.udoc = await user.getById(this.pdoc.owner);
|
|
|
|
this.response.body = {
|
|
|
|
pdoc: this.pdoc,
|
|
|
|
udoc: this.udoc,
|
|
|
|
title: (this.pdoc || {}).title || ''
|
|
|
|
};
|
|
|
|
}
|
|
|
|
async get() {
|
|
|
|
this.response.body.path = [
|
|
|
|
['Hydro', '/'],
|
|
|
|
['problem_main', '/p'],
|
|
|
|
[this.pdoc.title, null, true]
|
|
|
|
];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemSubmitHandler extends ProblemDetailHandler {
|
|
|
|
async prepare() {
|
|
|
|
this.checkPerm(PERM_SUBMIT_PROBLEM);
|
|
|
|
}
|
|
|
|
async get() {
|
|
|
|
this.response.template = 'problem_submit.html';
|
|
|
|
let rdocs = await record.getUserInProblemMulti(this.uid, this.pdoc._id).sort({ _id: -1 }).limit(10).toArray();
|
|
|
|
this.response.body = {
|
|
|
|
path: [
|
|
|
|
['Hydro', '/'],
|
|
|
|
['problem_main', '/p'],
|
|
|
|
[this.pdoc.title, `/p/${this.pid}`, true],
|
|
|
|
['problem_submit', null]
|
|
|
|
],
|
|
|
|
pdoc: this.pdoc,
|
|
|
|
udoc: this.udoc,
|
|
|
|
rdocs,
|
|
|
|
title: this.pdoc.title
|
|
|
|
};
|
|
|
|
}
|
|
|
|
async post() {
|
|
|
|
let { lang, code } = this.request.body;
|
|
|
|
let rid = await record.add({
|
|
|
|
uid: this.uid, lang, code, pid: this.pdoc._id
|
|
|
|
});
|
|
|
|
await queue.push('judge', rid);
|
|
|
|
this.user.nSubmit++;
|
|
|
|
this.response.body = { rid };
|
|
|
|
this.response.redirect = `/r/${rid}`;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemManageHandler extends ProblemDetailHandler {
|
|
|
|
async prepare() {
|
|
|
|
if (this.pdoc.owner != this.uid) this.checkPerm(PERM_EDIT_PROBLEM);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemSettingsHandler extends ProblemManageHandler {
|
|
|
|
async get() {
|
|
|
|
this.response.template = 'problem_settings.html';
|
|
|
|
this.ctx.body.path = [
|
|
|
|
['Hydro', '/'],
|
|
|
|
['problem_main', '/p'],
|
|
|
|
[this.pdoc.title, `/p/${this.pid}`, true],
|
|
|
|
['problem_settings', null]
|
|
|
|
];
|
|
|
|
}
|
|
|
|
async post() {
|
|
|
|
// TODO(masnn)
|
|
|
|
this.back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemEditHandler extends ProblemManageHandler {
|
|
|
|
async get() {
|
|
|
|
this.response.template = 'problem_edit.html';
|
|
|
|
this.response.body.path = [
|
|
|
|
['Hydro', '/'],
|
|
|
|
['problem_main', '/p'],
|
|
|
|
[this.pdoc.title, `/p/${this.request.params.pid}`, true],
|
|
|
|
['problem_edit', null]
|
|
|
|
];
|
|
|
|
this.response.body.page_name = 'problem_edit';
|
|
|
|
}
|
|
|
|
async post({ title, content }) {
|
|
|
|
let pid = validator.checkPid(this.request.body.pid);
|
|
|
|
let pdoc = await problem.get({ pid: this.params.pid });
|
|
|
|
await problem.edit(pdoc._id, { title, content, pid });
|
|
|
|
this.response.redirect = `/p/${pid}`;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemDataUploadHandler extends ProblemManageHandler {
|
|
|
|
constructor(ctx) {
|
|
|
|
super(ctx);
|
|
|
|
this.response.template = 'problem_upload.html';
|
|
|
|
}
|
|
|
|
async get() {
|
|
|
|
if (this.pdoc.data && typeof this.pdoc.data == 'object') {
|
|
|
|
let files = await gridfs.find({ _id: this.pdoc.data }).toArray();
|
|
|
|
this.md5 = files[0].md5;
|
|
|
|
}
|
|
|
|
this.response.body.md5 = this.md5;
|
|
|
|
}
|
|
|
|
async post() {
|
|
|
|
if (!this.request.files.file) throw new BadRequestError();
|
|
|
|
const r = fs.createReadStream(this.request.files.file.path);
|
|
|
|
let f = gridfs.openUploadStream('data.zip');
|
|
|
|
await new Promise((resolve, reject) => {
|
|
|
|
r.pipe(f);
|
|
|
|
f.once('finish', resolve);
|
|
|
|
f.once('error', reject);
|
|
|
|
});
|
|
|
|
if (this.pdoc.data && typeof this.pdoc.data == 'object')
|
|
|
|
gridfs.delete(this.pdoc.data);
|
|
|
|
this.pdoc = await problem.edit(this.pdoc._id, { data: f.id });
|
|
|
|
if (this.pdoc.data && typeof this.pdoc.data == 'object') {
|
|
|
|
let files = await gridfs.find({ _id: this.pdoc.data }).toArray();
|
|
|
|
this.md5 = files[0].md5;
|
|
|
|
}
|
|
|
|
this.response.body.md5 = this.md5;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemDataDownloadHandler extends ProblemDetailHandler {
|
|
|
|
async get({ pid }) {
|
|
|
|
if (this.uid != this.pdoc.owner) this.checkPerm([PERM_READ_PROBLEM_DATA, PERM_JUDGE]);
|
|
|
|
if (!this.pdoc.data) throw new ProblemDataNotFoundError(pid);
|
|
|
|
else if (typeof this.pdoc.data == 'string') this.ctx.setRedirect = this.pdoc.data.split('from:')[1];
|
|
|
|
this.response.attachment(`${this.pdoc.title}.zip`);
|
|
|
|
this.response.body = gridfs.openDownloadStream(this.pdoc.data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemSolutionHandler extends ProblemDetailHandler {
|
|
|
|
async get({ page = 1 }) {
|
|
|
|
this.response.template = 'problem_solution.html';
|
|
|
|
this.checkPerm(PERM_VIEW_PROBLEM_SOLUTION);
|
|
|
|
let [psdocs, pcount, pscount] = await paginate(solution.getMulti(this.pdoc._id), page, constants.SOLUTION_PER_PAGE);
|
|
|
|
let uids = [this.pdoc.owner], docids = [];
|
|
|
|
for (let psdoc of psdocs) {
|
|
|
|
docids.push(psdoc._id);
|
|
|
|
uids.push(psdoc.owner);
|
|
|
|
if (psdoc.reply.length)
|
|
|
|
for (let psrdoc of psdoc.reply)
|
|
|
|
uids.push(psrdoc.owner);
|
|
|
|
}
|
|
|
|
let udict = await user.getList(uids);
|
|
|
|
let pssdict = solution.getListStatus(docids, this.uid);
|
|
|
|
let path = [
|
|
|
|
['problem_main', '/p'],
|
|
|
|
[this.pdoc.title, `/p/${this.pdoc.pid}`, true],
|
|
|
|
['problem_solution', null]
|
|
|
|
];
|
|
|
|
this.response.body = {
|
|
|
|
path, psdocs, page, pcount, pscount, udict, pssdict
|
|
|
|
};
|
|
|
|
}
|
|
|
|
async post({ psid }) {
|
|
|
|
if (psid) this.psdoc = await solution.get(psid);
|
|
|
|
}
|
|
|
|
async post_submit({ content }) {
|
|
|
|
this.checkPerm(PERM_CREATE_PROBLEM_SOLUTION);
|
|
|
|
await solution.add(this.pdoc._id, this.uid, content);
|
|
|
|
this.back();
|
|
|
|
}
|
|
|
|
async post_edit_solution({ content }) {
|
|
|
|
if (this.psdoc.owner != this.uid) this.checkPerm(PERM_EDIT_PROBLEM_SOLUTION);
|
|
|
|
this.psdoc = await solution.edit(this.psdoc._id, content);
|
|
|
|
this.ctx.body.psdoc = this.psdoc;
|
|
|
|
this.back();
|
|
|
|
}
|
|
|
|
async post_delete_solution() {
|
|
|
|
if (this.psdoc.owner != this.uid) this.checkPerm(PERM_DELETE_PROBLEM_SOLUTION);
|
|
|
|
await solution.del(this.psdoc._id);
|
|
|
|
this.back();
|
|
|
|
}
|
|
|
|
async post_reply({ psid, content }) {
|
|
|
|
this.checkPerm(PERM_REPLY_PROBLEM_SOLUTION);
|
|
|
|
let psdoc = await solution.get(psid);
|
|
|
|
await solution.reply(psdoc._id, this.uid, content);
|
|
|
|
}
|
|
|
|
async post_edit_reply({ content, psid, psrid }) {
|
|
|
|
let [psdoc, psrdoc] = await solution.getReply(psid, psrid);
|
|
|
|
if ((!psdoc) || psdoc.pid != this.pdoc._id) throw new SolutionNotFoundError(psid);
|
|
|
|
if (psrdoc.owner != this.uid) this.checkPerm(PERM_EDIT_PROBLEM_SOLUTION_REPLY);
|
|
|
|
await solution.editReply(psid, psrid, content);
|
|
|
|
}
|
|
|
|
async post_delete_reply({ psid, psrid }) {
|
|
|
|
let [psdoc, psrdoc] = await solution.getReply(psid, psrid);
|
|
|
|
if ((!psdoc) || psdoc.pid != this.pdoc._id) throw new SolutionNotFoundError(psid);
|
|
|
|
if (psrdoc.owner != this.uid) this.checkPerm(PERM_EDIT_PROBLEM_SOLUTION_REPLY);
|
|
|
|
await solution.delReply(psid, psrid);
|
|
|
|
this.back();
|
|
|
|
}
|
|
|
|
async post_upvote() {
|
|
|
|
let [psdoc, pssdoc] = await solution.vote(this.psdoc._id, this.uid, 1);
|
|
|
|
this.response.body = { vote: psdoc.vote, user_vote: pssdoc.vote };
|
|
|
|
if (!this.preferJson) this.back();
|
|
|
|
}
|
|
|
|
async post_downvote() {
|
|
|
|
let [psdoc, pssdoc] = await solution.vote(this.psdoc._id, this.uid, -1);
|
|
|
|
this.response.body = { vote: psdoc.vote, user_vote: pssdoc.vote };
|
|
|
|
if (!this.preferJson) this.back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemSolutionRawHandler extends ProblemDetailHandler {
|
|
|
|
async get({ psid }) {
|
|
|
|
this.checkPerm(PERM_VIEW_PROBLEM_SOLUTION);
|
|
|
|
let psdoc = await solution.get(psid);
|
|
|
|
this.response.type = 'text/markdown';
|
|
|
|
this.response.body = psdoc.content;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemSolutionReplyRawHandler extends ProblemDetailHandler {
|
|
|
|
async get({ psid }) {
|
|
|
|
this.checkPerm(PERM_VIEW_PROBLEM_SOLUTION);
|
|
|
|
let [psdoc, psrdoc] = await solution.getReply(psid);
|
|
|
|
if ((!psdoc) || psdoc.pid != this.pdoc._id) throw new SolutionNotFoundError(psid);
|
|
|
|
this.response.type = 'text/markdown';
|
|
|
|
this.response.body = psrdoc.content;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class ProblemCreateHandler extends Handler {
|
|
|
|
async get() {
|
|
|
|
this.response.template = 'problem_edit.html';
|
|
|
|
this.checkPerm(PERM_CREATE_PROBLEM);
|
|
|
|
this.response.body = {
|
|
|
|
path: [
|
|
|
|
['Hydro', '/'],
|
|
|
|
['problem_main', '/p'],
|
|
|
|
['problem_create', null]
|
|
|
|
], page_name: 'problem_create'
|
|
|
|
};
|
|
|
|
}
|
|
|
|
async post({ title, pid, content, hidden }) {
|
|
|
|
validator.checkPid(pid);
|
|
|
|
pid = pid || await system.incPidCounter();
|
|
|
|
await problem.add({ title, content, owner: this.user._id, pid, hidden });
|
|
|
|
this.response.body = { pid };
|
|
|
|
this.response.redirect = `/p/${pid}/settings`;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Route('/p', ProblemHandler);
|
|
|
|
Route('/problem/random', ProblemRandomHandler);
|
|
|
|
Route('/p/:pid', ProblemDetailHandler);
|
|
|
|
Route('/p/:pid/submit', ProblemSubmitHandler);
|
|
|
|
Route('/p/:pid/settings', ProblemSettingsHandler);
|
|
|
|
Route('/p/:pid/edit', ProblemEditHandler);
|
|
|
|
Route('/p/:pid/upload', ProblemDataUploadHandler);
|
|
|
|
Route('/p/:pid/data', ProblemDataDownloadHandler);
|
|
|
|
Route('/p/:pid/solution', ProblemSolutionHandler);
|
|
|
|
Route('/p/:pid/solution/:psid/raw', ProblemSolutionRawHandler);
|
|
|
|
Route('/p/:pid/solution/:psid/:psrid/raw', ProblemSolutionReplyRawHandler);
|
|
|
|
Route('/problem/create', ProblemCreateHandler);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
@app.route('/p/{pid}/pretest', 'problem_pretest')
|
|
|
|
class ProblemPretestHandler(base.Handler):
|
|
|
|
@base.requirePerm(builtin.PERM_SUBMIT_PROBLEM)
|
|
|
|
@base.route_argument
|
|
|
|
@base.post_argument
|
|
|
|
@base.require_csrf_token
|
|
|
|
@base.sanitize
|
|
|
|
@base.limitRate('add_record', 60, 100)
|
|
|
|
async def post(self, *, pid: document.convert_doc_id, lang: str, code: str,
|
|
|
|
data_input: str, data_output: str):
|
|
|
|
pdoc = await problem.get(self.domainId, pid)
|
|
|
|
# don't need to check hidden status
|
|
|
|
# create zip file, TODO(twd2): check file size
|
|
|
|
post = await self.request.post()
|
|
|
|
content = list(zip(post.getall('data_input'), post.getall('data_output')))
|
|
|
|
output_buffer = io.BytesIO()
|
|
|
|
zip_file = zipfile.ZipFile(output_buffer, 'a', zipfile.ZIP_DEFLATED)
|
|
|
|
config_content = str(len(content)) + '\n'
|
|
|
|
for i, (data_input, data_output) in enumerate(content):
|
|
|
|
input_file = 'input{0}.txt'.format(i)
|
|
|
|
output_file = 'output{0}.txt'.format(i)
|
|
|
|
config_content += '{0}|{1}|1|10|262144\n'.format(input_file, output_file)
|
|
|
|
zip_file.writestr('Input/{0}'.format(input_file), data_input)
|
|
|
|
zip_file.writestr('Output/{0}'.format(output_file), data_output)
|
|
|
|
zip_file.writestr('Config.ini', config_content)
|
|
|
|
# mark all files as created in Windows :p
|
|
|
|
for zfile in zip_file.filelist:
|
|
|
|
zfile.create_system = 0
|
|
|
|
zip_file.close()
|
|
|
|
fid = await fs.add_data('application/zip', output_buffer.getvalue())
|
|
|
|
output_buffer.close()
|
|
|
|
rid = await record.add(self.domainId, pdoc['_id'], constant.record.TYPE_PRETEST,
|
|
|
|
self.user['_id'], lang, code, fid)
|
|
|
|
self.json_or_redirect(self.reverse_url('record_detail', rid=rid))
|
|
|
|
|
|
|
|
|
|
|
|
@app.connection_route('/p/{pid}/pretest-conn', 'problem_pretest-conn')
|
|
|
|
class ProblemPretestConnection(record_handler.RecordVisibilityMixin, base.Connection):
|
|
|
|
async def on_open(self):
|
|
|
|
await super(ProblemPretestConnection, self).on_open()
|
|
|
|
self.pid = document.convert_doc_id(self.request.match_info['pid'])
|
|
|
|
bus.subscribe(self.on_record_change, ['record_change'])
|
|
|
|
|
|
|
|
async def on_record_change(self, e):
|
|
|
|
rdoc = e['value']
|
|
|
|
if rdoc['uid'] != self.user['_id'] or \
|
|
|
|
rdoc['domainId'] != self.domainId or rdoc['pid'] != self.pid:
|
|
|
|
return
|
|
|
|
# check permission for visibility: contest
|
|
|
|
if rdoc['tid']:
|
|
|
|
show_status, tdoc = await self.rdoc_contest_visible(rdoc)
|
|
|
|
if not show_status:
|
|
|
|
return
|
|
|
|
self.send(rdoc=rdoc)
|
|
|
|
|
|
|
|
async def on_close(self):
|
|
|
|
bus.unsubscribe(self.on_record_change)
|
|
|
|
|
|
|
|
|
|
|
|
@base.requirePriv(builtin.PRIV_USER_PROFILE)
|
|
|
|
@base.route_argument
|
|
|
|
@base.post_argument
|
|
|
|
@base.require_csrf_token
|
|
|
|
@base.sanitize
|
|
|
|
async def post(self, *, pid: document.convert_doc_id, title: str, content: str):
|
|
|
|
pdoc = await problem.get(self.domainId, pid)
|
|
|
|
if not self.own(pdoc, builtin.PERM_EDIT_PROBLEM_SELF):
|
|
|
|
self.check_perm(builtin.PERM_EDIT_PROBLEM)
|
|
|
|
await problem.edit(self.domainId, pdoc['_id'], title=title, content=content)
|
|
|
|
self.json_or_redirect(self.reverse_url('problem_detail', pid=pid))
|
|
|
|
|
|
|
|
|
|
|
|
@app.route('/p/{pid}/statistics', 'problem_statistics')
|
|
|
|
class ProblemStatisticsHandler(base.Handler):
|
|
|
|
@base.route_argument
|
|
|
|
@base.sanitize
|
|
|
|
async def get(self, *, pid: document.convert_doc_id):
|
|
|
|
# TODO(twd2)
|
|
|
|
uid = self.user['_id'] if self.has_priv(builtin.PRIV_USER_PROFILE) else None
|
|
|
|
pdoc = await problem.get(self.domainId, pid, uid)
|
|
|
|
if pdoc.get('hidden', False):
|
|
|
|
self.check_perm(builtin.PERM_VIEW_PROBLEM_HIDDEN)
|
|
|
|
udoc, dudoc = await asyncio.gather(user.get_by_uid(pdoc['owner_uid']),
|
|
|
|
domain.get_user(self.domainId, pdoc['owner_uid']))
|
|
|
|
path_components = self.build_path(
|
|
|
|
(self.translate('problem_main'), self.reverse_url('problem_main')),
|
|
|
|
(pdoc['title'], self.reverse_url('problem_detail', pid=pdoc['_id'])),
|
|
|
|
(self.translate('problem_statistics'), None))
|
|
|
|
self.render('problem_statistics.html', pdoc=pdoc, udoc=udoc, dudoc=dudoc,
|
|
|
|
page_title=pdoc['title'], path_components=path_components)
|
|
|
|
|
|
|
|
*/
|