zj-to-hydrooj 1.0.0

package/index.ts

@@ -0,0 +1,166 @@
+import AdmZip from 'adm-zip';
+import { promises as fsNative } from 'fs';
+import {
+    buildContent, Context, Handler, PERM,
+    ProblemModel, Schema, ValidationError, yaml, 
+} from 'hydrooj';
+
+import { htmlToOJMarkdown } from './src/zjHtmlToMarkdown';
+
+// define ZJson Schema
+const ZJsonSchema = Schema.object({
+    title: Schema.string().required(),
+    problemid: Schema.string().required(),
+    author: Schema.string(),
+    content: Schema.string(),
+    theinput: Schema.string(),
+    theoutput: Schema.string(),
+    sampleinput: Schema.string(),
+    sampleoutput: Schema.string(),
+    hint: Schema.string(),
+    keywords: Schema.any(),
+    testfilelength: Schema.number().default(0),
+    testinfiles: Schema.array(Schema.string()),
+    testoutfiles: Schema.array(Schema.string()),
+    timelimits: Schema.any(),
+    memorylimit: Schema.number(),
+});
+
+class ImportJsonHandler extends Handler {
+    async processZJson(domainId: string, rawData: any) {
+        let data;
+        try {
+            data = ZJsonSchema(rawData);
+        } catch (e : any) {
+            throw new ValidationError('file', null, `Invalid ZJSON content: ${e.message}`);
+        }
+        const pidRegex = /^[a-zA-Z]\d{3}$/;
+        if (!pidRegex.test(data.problemid)) {
+            throw new ValidationError('problemid', `Invalid PID: ${data.problemid}. Must be one letter + 3 digits.`);
+        }
+
+        if (await ProblemModel.get(domainId, data.problemid)) {
+            throw new ValidationError('problemid', `PID ${data.problemid} already exists.`);
+        }
+
+        const convertHtmlToMarkdown = async (html: string): Promise<string> => {
+            if (!html) return '';
+            console.log('\n\n\nConverting HTML to Markdown. Original HTML:', html);
+             // Remove unnecessary backslashes before special characters throughout HTML
+            const result: string = htmlToOJMarkdown(html);
+            console.log('\n\n\nConverted HTML to Markdown:', result || '');
+            console.log('--- End of Conversion ---\n\n\n');
+            return result || '';
+        };
+
+        let descriptionMarkdown = await convertHtmlToMarkdown(data.content);
+
+        if (data.author) {
+            const authorUrl = `https://dandanjudge.fdhs.tyc.edu.tw/UserStatistic?account=${encodeURIComponent(data.author)}`;
+            descriptionMarkdown = `**Author**: [${data.author}](${authorUrl})\n\n${descriptionMarkdown}`;
+        }
+
+        const contentMarkdown = buildContent({
+            description: descriptionMarkdown,
+            input: await convertHtmlToMarkdown(data.theinput),
+            output: await convertHtmlToMarkdown(data.theoutput),
+            samples: [[data.sampleinput, data.sampleoutput]],
+            hint: await convertHtmlToMarkdown(data.hint),
+        }, 'markdown');
+        const tags = data.keywords ? (typeof data.keywords === 'string' ? JSON.parse(data.keywords) : data.keywords) : [];
+        const pid = await ProblemModel.add(
+            domainId, data.problemid, data.title, contentMarkdown,
+            this.user._id, tags,
+        );
+        const tasks = [];
+        const config = {
+            type: 'default',
+            time: Array.isArray(data.timelimits) ? `${data.timelimits[0]}s` : `${data.timelimits}s`,
+            memory: `${data.memorylimit}mb`,
+            subtasks: [] as any[],
+        };
+        if (!data.timelimits) config.time = '3s';
+        if (!data.memorylimit) config.memory = '100mb';
+        for (let i = 0; i < data.testfilelength; i++) {
+            const inName = `${i + 1}.in`;
+            const outName = `${i + 1}.out`;
+            const inContent = data.testinfiles && data.testinfiles[i] ? data.testinfiles[i] : "";
+            const outContent = data.testoutfiles && data.testoutfiles[i] ? data.testoutfiles[i] : "";
+            tasks.push(ProblemModel.addTestdata(domainId, pid, inName, Buffer.from(inContent || '')));
+            tasks.push(ProblemModel.addTestdata(domainId, pid, outName, Buffer.from(outContent   || '')));
+            config.subtasks.push({
+                cases: [{ input: inName, output: outName }]
+            });
+        }
+        tasks.push(ProblemModel.addTestdata(domainId, pid, 'config.yaml', Buffer.from(yaml.dump(config))));
+        await Promise.all(tasks);
+    }
+
+    async fromFile(domainId: string, filePath: string) {
+        const buf = await fsNative.readFile(filePath);
+        console.log('DEBUG: File head bytes:', buf[0], buf[1], buf[2], buf[3]);
+        console.log('DEBUG: Is Buffer?', Buffer.isBuffer(buf));
+        const isZip = buf[0] === 0x50 && buf[1] === 0x4b;
+
+        if (isZip) {
+            console.log('DEBUG: ZIP logic triggered');
+            try {
+                const zip = new AdmZip(buf);
+                const zipEntries = zip.getEntries();
+                const jsonEntries = zipEntries.filter((entry: AdmZip.IZipEntry) =>
+                    entry.entryName.toLowerCase().endsWith('.zjson')
+                );
+
+                if (jsonEntries.length === 0) throw new ValidationError('ZIP ?????? .zjson');
+                
+                for (const jsonEntry of jsonEntries) {
+                    const rawData = JSON.parse(jsonEntry.getData().toString('utf8'));
+                    try {
+                        await this.processZJson(domainId, rawData);
+                    } catch (e) {
+                        console.error(`Error processing ${jsonEntry.entryName}:`, e);
+                    }
+                }
+            } catch (e: any) {
+                throw new ValidationError('file', null, `ZIP??????: ${e.message}`);
+            }
+        } else {
+            console.log('DEBUG: Plain JSON logic triggered');
+            try {
+                const rawData = JSON.parse(buf.toString('utf8'));
+                await this.processZJson(domainId, rawData);
+            } catch (e: any) {
+                throw new ValidationError('file', null, `?JSON????: ${e.message}`);
+            }
+        }
+    }
+    async get() {
+        this.response.body = { type: 'JSON' };
+        this.response.template = 'problem_import.html';
+    }
+
+    async post({ domainId }: { domainId: string }) {
+        console.log('Post started');
+        const file = this.request.files.file;
+        if (!file) throw new ValidationError('file');
+
+        try {
+            console.log('File path:', file.filepath);
+            await this.fromFile(domainId, file.filepath);
+            console.log('fromFile finished');
+            this.response.redirect = this.url('problem_main', { domainId });
+        } catch (e: any) {
+            console.error('Import Error Trace:', e);
+            throw new ValidationError('file', null, `????:${e.message}`);
+        }
+    }
+}
+
+export async function apply(ctx : Context) {
+    ctx.Route('problem_import_json', '/problem/import/json', ImportJsonHandler, PERM.PERM_CREATE_PROBLEM);
+    ctx.injectUI('ProblemAdd', 'problem_import_json', { icon: 'copy', text: 'From JSON/ZIP Export' });
+    ctx.i18n.load('zh', {
+        'From JSON/ZIP Export': 'Import from DDJ-v1',
+    });
+}
+

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "zj-to-hydrooj",
+  "version": "1.0.0",
+  "description": "JSON to Hydro import plugin",
+  "main": "index.js",
+  "type": "module",
+  "keywords": [
+    "hydrooj",
+    "fdcs"
+  ],
+  "author": "Miyun",
+  "license": "MIT",
+  "dependencies": {
+    "js-yaml": "^4.1.1",
+    "jsdom": "^27.4.0",
+    "jszip": "^3.10.1",
+    "pandoc-ts": "^1.0.5"
+  }
+}

package/src/zjHtmlToMarkdown.js

@@ -0,0 +1,227 @@
+const { JSDOM } = require('jsdom');
+
+export function htmlToOJMarkdown(html) {
+  const dom = new JSDOM(html);
+  const document = dom.window.document;
+
+  return walk(document.body)
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/(\$\$[^\$]*\$\$)/g, '$1\n')
+    .trim();
+}
+
+function walk(node) {
+  if (node.nodeType === node.TEXT_NODE) {
+    return node.textContent ?? '';
+  }
+
+  if (node.nodeType === node.ELEMENT_NODE) {
+    const el = node;
+    const children = Array.from(el.childNodes).map(walk).join('');
+
+    switch (el.tagName.toLowerCase()) {
+      case 'h1': return `<h1> ${children}</h1>\n\n`;
+      case 'h2': return `<h2> ${children}</h2>\n\n`;
+      case 'h3': return `<h3> ${children}</h3>\n\n`;
+      case 'h4': return `<h4> ${children}</h4>\n\n`;
+      case 'h5': return `<h5> ${children}</h5>\n\n`;
+      case 'h6': return `<h6> ${children}</h6>\n\n`;
+      case 'p': return `${children}\n\n`;
+      case 'strong': return `<strong>${children}</strong>`;
+      case 'em': return `<em>${children}</em>`;
+      case 'sup': return `<sup>${children}</sup>`;
+      case 'sub': return `<sub>${children}</sub>`;
+      case 'code':
+        return el.parentElement?.tagName.toLowerCase() === 'pre'
+          ? children
+          : `<code>${children}</code>`;
+      case 'pre':
+        return `\n\`\`\`\n${children}\n\`\`\`\n`;
+      case 'ul':
+        return `\n${children}`;
+      case 'ol':
+        return `\n${renderOrderedList(el)}`;
+      case 'li':
+        return `- ${children}\n`;
+      case 'img':
+        return renderImage(el);
+      case 'span':
+        return renderSpan(el);
+      case 'table':
+        return renderTable(el);
+      case 'hr':
+        return `\n---\n\n`;
+      case 'br':
+        return `\n`;
+      case 'div':
+        return `${children}\n`;
+      default:
+        return children;
+    }
+  }
+
+  return '';
+}
+
+function renderSpan(el) {
+  const cls = el.className;
+  const children = Array.from(el.childNodes).map(walk).join('');
+
+  // Math spans
+  if (cls.includes('math-inline') || cls.includes('MathJax')) {
+    return `$${extractMath(el)}$`;
+  }
+  if (cls.includes('math-display')) {
+    return `\n$$\n${extractMath(el)}\n$$\n`;
+  }
+
+  // Style-based decorations
+  const dec = (el.style && typeof el.style.textDecoration === 'string')
+    ? el.style.textDecoration.toLowerCase()
+    : '';
+  if (dec.includes('underline')) {
+    return `<u>${children}</u>`;
+  }
+  if (dec.includes('line-through')) {
+    return `~~${children}~~`;
+  }
+
+  // Fallback to raw style attribute parsing
+  const styleAttr = (el.getAttribute('style') || '').toLowerCase();
+  if (styleAttr.includes('text-decoration') && styleAttr.includes('underline')) {
+    return `<u>${children}</u>`;
+  }
+  if (styleAttr.includes('text-decoration') && styleAttr.includes('line-through')) {
+    return `~~${children}~~`;
+  }
+
+  return children;
+}
+
+function extractMath(el) {
+  return normalizeMath(el.textContent ?? '');
+}
+
+// LaTeX command to Unicode symbol mapping
+const LATEX_TO_UNICODE = {
+  // Comparison operators
+  '\\leq': '≤', '\\le': '≤',
+  '\\geq': '≥', '\\ge': '≥',
+  '\\neq': '≠', '\\ne': '≠',
+  '\\approx': '≈',
+  '\\equiv': '≡',
+  
+  // Arithmetic operators
+  '\\times': '×',
+  '\\cdot': '·',
+  '\\div': '÷',
+  '\\pm': '±',
+  '\\mp': '∓',
+  
+  // Arrows
+  '\\to': '→', '\\rightarrow': '→',
+  '\\leftarrow': '←',
+  '\\leftrightarrow': '↔',
+  '\\Rightarrow': '⇒',
+  '\\Leftarrow': '⇐',
+  '\\Leftrightarrow': '⇔',
+  
+  // Greek letters (lowercase)
+  '\\alpha': 'α', '\\beta': 'β', '\\gamma': 'γ', '\\delta': 'δ',
+  '\\epsilon': 'ε', '\\zeta': 'ζ', '\\eta': 'η', '\\theta': 'θ',
+  '\\iota': 'ι', '\\kappa': 'κ', '\\lambda': 'λ', '\\mu': 'μ',
+  '\\nu': 'ν', '\\xi': 'ξ', '\\pi': 'π', '\\rho': 'ρ',
+  '\\sigma': 'σ', '\\tau': 'τ', '\\upsilon': 'υ', '\\phi': 'φ',
+  '\\chi': 'χ', '\\psi': 'ψ', '\\omega': 'ω',
+  
+  // Greek letters (uppercase)
+  '\\Gamma': 'Γ', '\\Delta': 'Δ', '\\Theta': 'Θ', '\\Lambda': 'Λ',
+  '\\Xi': 'Ξ', '\\Pi': 'Π', '\\Sigma': 'Σ', '\\Phi': 'Φ',
+  '\\Psi': 'Ψ', '\\Omega': 'Ω',
+  
+  // Logic symbols
+  '\\forall': '∀', '\\exists': '∃',
+  '\\wedge': '∧', '\\vee': '∨', '\\neg': '¬',
+  '\\land': '∧', '\\lor': '∨',
+  
+  // Set theory
+  '\\in': '∈', '\\notin': '∉',
+  '\\subset': '⊂', '\\subseteq': '⊆',
+  '\\supset': '⊃', '\\supseteq': '⊇',
+  '\\cup': '∪', '\\cap': '∩',
+  '\\emptyset': '∅',
+  
+  // Misc
+  '\\infty': '∞', '\\partial': '∂',
+  '\\nabla': '∇', '\\sum': '∑',
+  '\\prod': '∏', '\\int': '∫',
+};
+
+function normalizeMath(s) {
+  // Normalize whitespace first
+  s = s.replace(/\s+/g, ' ');
+  
+  // Replace all known LaTeX commands with Unicode equivalents
+  // Sort by length (descending) to match longer commands first
+  const commands = Object.keys(LATEX_TO_UNICODE).sort((a, b) => b.length - a.length);
+  for (const cmd of commands) {
+    s = s.replace(new RegExp(cmd.replace(/\\/g, '\\\\'), 'g'), LATEX_TO_UNICODE[cmd]);
+  }
+  
+  // Remove any remaining unrecognized LaTeX commands
+  s = s.replace(/\\[a-zA-Z]+/g, '');
+  
+  // Remove any remaining backslashes
+  s = s.replace(/\\/g, '');
+  
+  return s.trim();
+}
+
+function renderImage(el) {
+  const src = el.getAttribute('src') ?? '';
+  const alt = el.getAttribute('alt') ?? '';
+  return `![${alt}](${src})`;
+}
+
+function renderOrderedList(el) {
+  let counter = 1;
+  return Array.from(el.childNodes)
+    .filter(node => node.nodeType === node.ELEMENT_NODE && node.tagName.toLowerCase() === 'li')
+    .map(li => {
+      const content = Array.from(li.childNodes).map(walk).join('');
+      return `${counter++}. ${content}\n`;
+    })
+    .join('');
+}
+
+function renderTable(el) {
+  const rows = Array.from(el.querySelectorAll('tr'));
+  if (rows.length === 0) return '';
+
+  let table = '\n| ';
+  
+  // Process header row
+  const headerCells = rows[0].querySelectorAll('td, th');
+  table += Array.from(headerCells)
+    .map(cell => Array.from(cell.childNodes).map(walk).join('').trim())
+    .join(' | ');
+  table += ' |\n|';
+  
+  // Add separator
+  for (let i = 0; i < headerCells.length; i++) {
+    table += ' --- |';
+  }
+  table += '\n';
+  
+  // Process data rows
+  for (let i = 1; i < rows.length; i++) {
+    table += '| ';
+    const cells = rows[i].querySelectorAll('td, th');
+    table += Array.from(cells)
+      .map(cell => Array.from(cell.childNodes).map(walk).join('').trim() || '&nbsp;')
+      .join(' | ');
+    table += ' |\n';
+  }
+  
+  return table + '\n';
+}