feat: import problems from qduoj

packages/import-qduoj/handler.ts

@@ -0,0 +1,127 @@
+/* eslint-disable no-await-in-loop */
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import AdmZip from 'adm-zip';
+import yaml from 'js-yaml';
+import { ObjectID } from 'mongodb';
+import { LocalProblemConfig } from 'hydrooj';
+import {
+    Route, Handler, param, Types,
+} from 'hydrooj/dist/service/server';
+import { BadRequestError } from 'hydrooj/dist/error';
+import { streamToBuffer } from 'hydrooj/dist/utils';
+import { ProblemAdd } from 'hydrooj/dist/lib/ui';
+import * as file from 'hydrooj/dist/model/file';
+import * as problem from 'hydrooj/dist/model/problem';
+import { PERM } from 'hydrooj/dist/model/builtin';
+
+const processing = {};
+fs.ensureDirSync('/tmp/hydro/import-qduoj');
+
+class ImportQduojHandler extends Handler {
+    async ImportFromFile(domainId: string, id: string, zipfile: Buffer) {
+        const zip = new AdmZip(zipfile);
+        const tmp = path.resolve(os.tmpdir(), 'hydro', 'import-qduoj', id);
+        await new Promise((resolve, reject) => {
+            zip.extractAllToAsync(tmp, true, (err) => (err ? resolve() : reject(err)));
+        });
+        try {
+            const folders = await fs.readdir(tmp);
+            for (const folder of folders) {
+                const buf = await fs.readFile(path.join(tmp, folder, 'problem.json'));
+                const pdoc = JSON.parse(buf.toString());
+                const content = [
+                    ...pdoc.description?.value
+                        ? [
+                            '<h2>Description</h2>',
+                            pdoc.description.value,
+                        ] : [],
+                    ...pdoc.input_description?.value
+                        ? [
+                            '<h2>Input Description</h2>',
+                            pdoc.input_description.value,
+                        ] : [],
+                    ...pdoc.output_description?.value
+                        ? [
+                            '<h2>Output Description</h2>',
+                            pdoc.output_description.value,
+                        ] : [],
+                    ...(pdoc.samples as any[]).map((sample, i) => [
+                        `<h2>Sample Input ${i + 1}</h2><pre>`,
+                        sample.input,
+                        `</pre><h2>Sample Output ${i + 1}</h2><pre>`,
+                        sample.output,
+                        '</pre>',
+                    ].join('\n')),
+                    ...pdoc.hint?.value
+                        ? [
+                            '<h2>Hint</h2>',
+                            pdoc.hint.value,
+                        ] : [],
+                    ...pdoc.source ? ['<h2>Source</h2>', pdoc.source] : [],
+                ].join('\n');
+                const pid = await problem.add(domainId, pdoc.display_id, pdoc.title, content, this.user._id, pdoc.tags);
+                const testdata = new AdmZip();
+                const config: LocalProblemConfig = {
+                    time: `${pdoc.time_limit}ms`,
+                    memory: `${pdoc.memory_limit}m`,
+                    subtasks: [],
+                };
+                for (const tc of pdoc.test_case_score) {
+                    testdata.addLocalFile(path.join(tmp, 'testcase', tc.input_name));
+                    testdata.addLocalFile(path.join(tmp, 'testcase', tc.output_name));
+                    config.subtasks.push({
+                        score: tc.score,
+                        cases: [{
+                            input: tc.input_name,
+                            output: tc.output_name,
+                        }],
+                    });
+                }
+                testdata.addFile('config.yaml', Buffer.from(yaml.safeDump(config)));
+                const f = path.resolve(os.tmpdir(), 'hydro', `${Math.random()}.zip`);
+                await new Promise((resolve, reject) => {
+                    testdata.writeZip(f, (err) => (err ? resolve() : reject(err)));
+                });
+                try {
+                    await problem.setTestdata(domainId, pid, f);
+                    await problem.edit(domainId, pid, { html: true });
+                } finally {
+                    await fs.unlink(f);
+                }
+            }
+        } finally {
+            await fs.remove(tmp);
+        }
+    }
+
+    @param('ufid', Types.ObjectID, true)
+    async get(domainId: string, ufid?: ObjectID) {
+        if (ufid) {
+            if (processing[ufid.toHexString()]) {
+                this.response.body = 'Processing';
+                return;
+            }
+            const stat = await file.getMeta(ufid);
+            if (stat.size > 128 * 1024 * 1024) throw new BadRequestError('File too large');
+            const stream = await file.get(ufid);
+            processing[ufid.toHexString()] = true;
+            try {
+                const buf = await streamToBuffer(stream);
+                await this.ImportFromFile(domainId, ufid.toHexString(), buf);
+                await file.del(ufid);
+            } catch (e) {
+                processing[ufid.toHexString()] = false;
+                throw e;
+            }
+        } else this.response.template = 'problem_import_qduoj.html';
+    }
+}
+
+export async function apply() {
+    Route('problem_import_qduoj', '/problem/import/qduoj', ImportQduojHandler, PERM.PERM_CREATE_PROBLEM);
+    ProblemAdd('problem_import_qduoj', {}, 'copy', 'From QDUOJ Export');
+}
+
+global.Hydro.handler.qduImport = apply;