workspace: upgrade deps & sort imports

pull/199/head
undefined 3 years ago
parent 336432cc4f
commit 8b30a9218b

@ -10,6 +10,7 @@ globals:
parser: '@typescript-eslint/parser'
plugins:
- '@typescript-eslint'
- simple-import-sort
rules:
'@typescript-eslint/dot-notation': 0
'@typescript-eslint/no-implied-eval': 0
@ -30,6 +31,7 @@ rules:
global-require: 0
guard-for-in: 0
implicit-arrow-linebreak: 0
import/extensions: 0
import/newline-after-import: 0
import/no-cycle: 0
import/no-extraneous-dependencies: 0
@ -55,6 +57,17 @@ rules:
no-return-await: 0
no-underscore-dangle: 0
prefer-destructuring: 0
simple-import-sort/imports:
- warn
- groups:
- ["^\\u0000"]
-
- "^(assert|buffer|child_process|cluster|console|constants|crypto|dgram|dns|domain|events|fs|http|https|module|net|os|path|punycode|querystring|readline|repl|stream|string_decoder|sys|timers|tls|tty|url|util|vm|zlib|freelist|v8|process|async_hooks|http2|perf_hooks)(/.*|$)"
- "^(?!@?hydrooj)(@?\\w.+)"
- "^@?hydrooj"
- "^"
- "^\\."
simple-import-sort/exports: 0
settings:
import/parsers:
'@typescript-eslint/parser':

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

@ -1,11 +1,17 @@
nodeLinker: node-modules
npmPublishAccess: public
packageExtensions:
koa-body@*:
dependencies:
"@types/koa": "*"
koa: "*"
plugins:
- path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
spec: "@yarnpkg/plugin-interactive-tools"
nodeLinker: node-modules
- path: .yarn/plugins/@yarnpkg/plugin-typescript.cjs
spec: "@yarnpkg/plugin-typescript"
yarnPath: .yarn/releases/yarn-berry.js
npmPublishAccess: "public"

@ -17,8 +17,8 @@
"lint:ui:ci": "yarn run --cwd=packages/ui-default eslint .",
"pub": "node build/publish",
"typedoc": "cross-env NODE_OPTIONS=--max_old_space_size=8192 typedoc",
"debug:all": "node --async-stack-traces --trace-deprecation --enable-source-maps build/start --debug --template",
"debug": "node --async-stack-traces --trace-deprecation --enable-source-maps node_modules/hydrooj/bin/hydrooj --debug --template",
"debug:all": "node --async-stack-traces --trace-deprecation build/start --debug --template",
"debug": "node --async-stack-traces --trace-deprecation node_modules/hydrooj/bin/hydrooj --debug --template",
"start:all": "node build/start",
"start": "node_modules/.bin/hydrooj",
"postinstall": "node build/hack",
@ -28,26 +28,27 @@
"license": "AGPL-3.0-only",
"devDependencies": {
"@types/cross-spawn": "^6.0.2",
"@types/node": "^16.7.8",
"@types/node": "^16.9.1",
"@types/semver": "^7.3.8",
"@typescript-eslint/eslint-plugin": "^4.30.0",
"@typescript-eslint/parser": "^4.30.0",
"@typescript-eslint/eslint-plugin": "^4.31.0",
"@typescript-eslint/parser": "^4.31.0",
"cac": "^6.7.3",
"cross-env": "^7.0.3",
"cross-spawn": "^7.0.3",
"esbuild": "^0.12.24",
"esbuild": "^0.12.26",
"eslint": "^7.32.0",
"eslint-config-airbnb-typescript": "^12.3.1",
"eslint-config-airbnb-typescript": "^14.0.0",
"eslint-import-resolver-typescript": "^2.4.0",
"eslint-plugin-import": "^2.24.2",
"eslint-plugin-simple-import-sort": "^7.0.0",
"fs-extra": "^10.0.0",
"globby": "^11.0.4",
"globby": "^12.0.2",
"latest-version": "^6.0.0",
"mongodb": "^3.6.12",
"mongodb": "^3.7.0",
"nmls": "^3.0.1",
"ora": "^5.4.1",
"ora": "^6.0.0",
"semver": "^7.3.5",
"typedoc": "^0.21.9",
"typescript": "4.2.4"
"typescript": "4.4.2"
}
}

@ -1,9 +1,9 @@
import crypto from 'crypto';
import yaml from 'js-yaml';
import db from 'hydrooj/src/service/db';
import {
Handler, post, Route, Types,
} from 'hydrooj/src/service/server';
import crypto from 'crypto';
import yaml from 'js-yaml';
function decrypt(encrypted: string) {
if (!encrypted) throw new Error();

@ -1,7 +1,7 @@
import yaml from 'js-yaml';
import * as bus from 'hydrooj/src/service/bus';
import * as system from 'hydrooj/src/model/system';
import i18n from 'hydrooj/src/lib/i18n';
import * as system from 'hydrooj/src/model/system';
import * as bus from 'hydrooj/src/service/bus';
bus.once('app/started', () => {
const langs = system.get('easy-locale.langs');

@ -1,17 +1,17 @@
/* eslint-disable no-await-in-loop */
import AdmZip from 'adm-zip';
import xml2js from 'xml2js';
import decodeHTML from 'decode-html';
import fs from 'fs-extra';
import { filter } from 'lodash';
import decodeHTML from 'decode-html';
import { Route, Handler } from 'hydrooj/src/service/server';
import xml2js from 'xml2js';
import type { ContentNode, ProblemConfigFile } from 'hydrooj';
import { FileTooLargeError, ValidationError } from 'hydrooj/src/error';
import { buildContent } from 'hydrooj/src/lib/content';
import { ProblemAdd } from 'hydrooj/src/lib/ui';
import solution from 'hydrooj/src/model/solution';
import problem from 'hydrooj/src/model/problem';
import { PERM } from 'hydrooj/src/model/builtin';
import { FileTooLargeError, ValidationError } from 'hydrooj/src/error';
import type { ContentNode, ProblemConfigFile } from 'hydrooj';
import problem from 'hydrooj/src/model/problem';
import solution from 'hydrooj/src/model/solution';
import { Handler, Route } from 'hydrooj/src/service/server';
class FpsProblemImportHandler extends Handler {
async get() {

@ -11,7 +11,7 @@
"adm-zip": "^0.5.5",
"decode-html": "^2.0.0",
"fs-extra": "^10.0.0",
"mongodb": "^3.6.12",
"mongodb": "^3.7.0",
"xml2js": "^0.4.23"
},
"devDependencies": {

@ -1,4 +1,5 @@
import 'hydrooj';
import fs from 'fs';
import { Reader } from 'maxmind';
import { findFileSync } from '@hydrooj/utils/lib/utils';

@ -7,16 +7,16 @@
"repository": "https://github.com/hydro-dev/Hydro.git",
"dependencies": {
"@hydrooj/utils": "workspace:*",
"axios": "^0.21.1",
"axios": "^0.21.4",
"cac": "^6.7.3",
"esbuild": "^0.12.24",
"esbuild": "^0.12.26",
"fs-extra": "^10.0.0",
"js-yaml": "^4.1.0",
"lodash": "^4.17.21",
"mongodb": "^3.6.12",
"mongodb": "^3.7.0",
"p-queue": "^7.1.0",
"shell-quote": "^1.7.2",
"ws": "^8.2.1"
"ws": "^8.2.2"
},
"preferUnplugged": true,
"license": "AGPL-3.0-or-later",

@ -1,8 +1,8 @@
import path from 'path';
import fs from 'fs-extra';
import cac from 'cac';
import { Logger } from './log';
import fs from 'fs-extra';
import { getConfig } from './config';
import { Logger } from './log';
const argv = cac().parse();

@ -1,12 +1,12 @@
import fs from 'fs-extra';
import path from 'path';
import fs from 'fs-extra';
import yaml from 'js-yaml';
import { max, sum } from 'lodash';
import readYamlCases, { convertIniConfig } from '@hydrooj/utils/lib/cases';
import { changeErrorType } from '@hydrooj/utils/lib/utils';
import { FormatError, SystemError } from './error';
import { parseTimeMS, parseMemoryMB, ensureFile } from './utils';
import { getConfig } from './config';
import { FormatError, SystemError } from './error';
import { ensureFile, parseMemoryMB, parseTimeMS } from './utils';
interface Re0 {
reg: RegExp,

@ -1,8 +1,8 @@
/* eslint-disable no-template-curly-in-string */
import { SystemError } from './error';
import { run } from './sandbox';
import * as STATUS from './status';
import { parse } from './testlib';
import { run } from './sandbox';
import { SystemError } from './error';
interface CheckResult {
status: number,

@ -1,9 +1,9 @@
import { LangConfig } from '@hydrooj/utils/lib/lang';
import * as STATUS from './status';
import { run, del } from './sandbox';
import { CompileError } from './error';
import { compilerText } from './utils';
import { Execute } from './interface';
import { del, run } from './sandbox';
import * as STATUS from './status';
import { compilerText } from './utils';
export = async function compile(
lang: LangConfig, code: string, target: string, copyIn: any = {}, next?: Function,

@ -1,7 +1,7 @@
/* eslint-disable prefer-const */
import cac from 'cac';
import os from 'os';
import path from 'path';
import cac from 'cac';
import fs from 'fs-extra';
import yaml from 'js-yaml';

@ -12,10 +12,10 @@
`-.__ 听取人生经验。 __.-'
````- - -.......- - -''' ~
~ */
import * as Session from './hosts/index';
import { sleep, Queue } from './utils';
import { getConfig } from './config';
import * as Session from './hosts/index';
import log from './log';
import { Queue, sleep } from './utils';
declare global {
namespace NodeJS {

@ -1,24 +1,24 @@
/* eslint-disable no-await-in-loop */
import path from 'path';
import axios from 'axios';
import fs from 'fs-extra';
import WebSocket from 'ws';
import PQueue from 'p-queue';
import cac from 'cac';
import fs from 'fs-extra';
import { noop } from 'lodash';
import { ObjectID } from 'mongodb';
import PQueue from 'p-queue';
import WebSocket from 'ws';
import { LangConfig } from '@hydrooj/utils/lib/lang';
import * as tmpfs from '../tmpfs';
import readCases from '../cases';
import { getConfig } from '../config';
import { CompileError, FormatError, SystemError } from '../error';
import judge from '../judge';
import log from '../log';
import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from '../status';
import * as sysinfo from '../sysinfo';
import * as tmpfs from '../tmpfs';
import {
compilerText, Lock, md5, Queue,
} from '../utils';
import { getConfig } from '../config';
import { FormatError, CompileError, SystemError } from '../error';
import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from '../status';
import readCases from '../cases';
import judge from '../judge';
import * as sysinfo from '../sysinfo';
const argv = cac().parse();

@ -1,14 +1,14 @@
import Queue from 'p-queue';
import path from 'path';
import fs from 'fs-extra';
import * as STATUS from '../status';
import Queue from 'p-queue';
import { check, compileChecker } from '../check';
import compile from '../compile';
import { getConfig } from '../config';
import { CompileError, SystemError } from '../error';
import { parseFilename } from '../utils';
import { run } from '../sandbox';
import compile from '../compile';
import signals from '../signals';
import { check, compileChecker } from '../check';
import { getConfig } from '../config';
import * as STATUS from '../status';
import { parseFilename } from '../utils';
const Score = {
sum: (a: number, b: number) => (a + b),

@ -1,13 +1,13 @@
// Not implemented
import path from 'path';
import fs from 'fs-extra';
import * as STATUS from '../status';
import { check, compileChecker } from '../check';
import compile from '../compile';
import { CompileError } from '../error';
import { copyInDir, parseFilename } from '../utils';
import { run } from '../sandbox';
import compile from '../compile';
import signals from '../signals';
import { check, compileChecker } from '../check';
import * as STATUS from '../status';
import { copyInDir, parseFilename } from '../utils';
export const judge = async (ctx) => {
if (ctx.config.template) {

@ -1,8 +1,8 @@
import * as def from './default';
import * as hack from './hack';
import * as interactive from './interactive';
import * as run from './run';
import * as submit_answer from './submit_answer';
import * as hack from './hack';
export = {
default: def, interactive, run, submit_answer, hack, objective: submit_answer,

@ -1,12 +1,12 @@
import Queue from 'p-queue';
import fs from 'fs-extra';
import Queue from 'p-queue';
import compile from '../compile';
import { getConfig } from '../config';
import { run } from '../sandbox';
import signals from '../signals';
import * as STATUS from '../status';
import { parse } from '../testlib';
import { findFileSync, parseFilename } from '../utils';
import { run } from '../sandbox';
import compile from '../compile';
import signals from '../signals';
import { getConfig } from '../config';
const testlibSrc = findFileSync('@hydrooj/hydrojudge/vendor/testlib/testlib.h');
const Score = {

@ -1,11 +1,11 @@
import fs from 'fs-extra';
import path from 'path';
import * as STATUS from '../status';
import { run } from '../sandbox';
import fs from 'fs-extra';
import compile from '../compile';
import { CompileError } from '../error';
import { run } from '../sandbox';
import signals from '../signals';
import * as STATUS from '../status';
import { compilerText, parseMemoryMB, parseTimeMS } from '../utils';
import { CompileError } from '../error';
export const judge = async (ctx) => {
ctx.stat.judge = new Date();

@ -1,4 +1,4 @@
import { inspect, InspectOptions, format } from 'util';
import { format, inspect, InspectOptions } from 'util';
import cac from 'cac';
const argv = cac().parse();

@ -1,11 +1,11 @@
import Axios from 'axios';
import fs from 'fs-extra';
import cac from 'cac';
import * as STATUS from './status';
import { FormatError, SystemError } from './error';
import { cmd, parseMemoryMB } from './utils';
import fs from 'fs-extra';
import { getConfig } from './config';
import { FormatError, SystemError } from './error';
import { Logger } from './log';
import * as STATUS from './status';
import { cmd, parseMemoryMB } from './utils';
const argv = cac().parse();
const logger = new Logger('sandbox');

@ -1,19 +1,20 @@
// Hydro Integration
/* eslint-disable no-await-in-loop */
import 'hydrooj';
import path from 'path';
import { ObjectID } from 'mongodb';
import fs from 'fs-extra';
import { noop } from 'lodash';
import { ObjectID } from 'mongodb';
import { Logger } from 'hydrooj/src/logger';
import * as monitor from 'hydrooj/src/service/monitor';
import readCases from './cases';
import { getConfig } from './config';
import { CompileError, FormatError, SystemError } from './error';
import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from './status';
import * as sysinfo from './sysinfo';
import * as tmpfs from './tmpfs';
import { FormatError, CompileError, SystemError } from './error';
import { STATUS_COMPILE_ERROR, STATUS_SYSTEM_ERROR } from './status';
import { compilerText, md5 } from './utils';
import readCases from './cases';
import { getConfig } from './config';
declare module 'hydrooj/src/interface' {
interface SystemKeys {

@ -2,9 +2,9 @@ import path from 'path';
import fs from 'fs-extra';
import { noop } from 'lodash';
import { get as _get } from '@hydrooj/utils/lib/sysinfo';
import { getConfig } from './config';
import { judge } from './judge/run';
import * as tmpfs from './tmpfs';
import { getConfig } from './config';
export { update } from '@hydrooj/utils/lib/sysinfo';

@ -1,6 +1,6 @@
import child from 'child_process';
import fs from 'fs-extra';
import os from 'os';
import fs from 'fs-extra';
import log from './log';
const linux = os.platform() === 'linux';

@ -1,9 +1,9 @@
import fs from 'fs-extra';
import crypto from 'crypto';
import { EventEmitter } from 'events';
import path from 'path';
import { parse } from 'shell-quote';
import fs from 'fs-extra';
import _ from 'lodash';
import { EventEmitter } from 'events';
import { parse } from 'shell-quote';
import { sleep } from '@hydrooj/utils/lib/utils';
import { FormatError } from './error';

@ -19,8 +19,8 @@
"cookies": "^0.8.0",
"detect-browser": "^5.2.0",
"fs-extra": "^10.0.0",
"graphql": "^15.5.2",
"graphql-scalars": "^1.10.0",
"graphql": "^15.5.3",
"graphql-scalars": "^1.10.1",
"js-yaml": "^4.1.0",
"koa": "^2.13.1",
"koa-body": "^4.2.0",
@ -33,19 +33,18 @@
"mime-types": "^2.1.32",
"minio": "7.0.17",
"moment-timezone": "^0.5.33",
"mongodb": "^3.6.12",
"mongodb": "^3.7.0",
"nanoid": "^3.1.25",
"nodemailer": "^6.6.3",
"p-queue": "^7.1.0",
"reflect-metadata": "^0.1.13",
"serialize-javascript": "^6.0.0",
"sockjs": "^0.3.21",
"source-map-support": "^0.5.19",
"source-map-support": "^0.5.20",
"superagent": "^6.1.0"
},
"devDependencies": {
"@types/adm-zip": "^0.4.34",
"@types/express-serve-static-core": "^4.17.24",
"@types/fs-extra": "^9.0.12",
"@types/js-yaml": "^4.0.3",
"@types/koa": "^2.13.4",

@ -1,15 +1,15 @@
/* eslint-disable no-await-in-loop */
/* eslint-disable import/no-dynamic-require */
import { ObjectID } from 'mongodb';
import cac from 'cac';
import {
lib, service, model, script,
builtinLib, builtinModel, builtinScript,
} from './common';
import options from '../options';
import { ObjectID } from 'mongodb';
import { validate } from '../lib/validator';
import options from '../options';
import * as bus from '../service/bus';
import db from '../service/db';
import {
builtinLib, builtinModel, builtinScript,
lib, model, script,
service,
} from './common';
const argv = cac().parse();
const COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;

@ -1,8 +1,8 @@
/* eslint-disable no-await-in-loop */
/* eslint-disable no-eval */
import fs from 'fs-extra';
import os from 'os';
import path from 'path';
import fs from 'fs-extra';
import yaml from 'js-yaml';
import { Logger } from '../logger';
import * as bus from '../service/bus';

@ -1,12 +1,12 @@
import http from 'http';
import os from 'os';
import path from 'path';
import http from 'http';
import cac from 'cac';
import fs from 'fs-extra';
import Koa, { Context } from 'koa';
import Body from 'koa-body';
import cache from 'koa-static-cache';
import mongodb from 'mongodb';
import cac from 'cac';
import { Logger } from '../logger';
const logger = new Logger('setup');

@ -1,17 +1,16 @@
/* eslint-disable no-await-in-loop */
/* eslint-disable import/no-dynamic-require */
import os from 'os';
import fs from 'fs-extra';
import path from 'path';
import cac from 'cac';
import {
locale, template, lib, service, model, handler, script, setting, uistatic,
builtinLib, builtinScript, builtinHandler, builtinModel,
} from './common';
import fs from 'fs-extra';
import { Logger } from '../logger';
import options from '../options';
import * as bus from '../service/bus';
import db from '../service/db';
import { Logger } from '../logger';
import {
builtinHandler, builtinLib, builtinModel,
builtinScript, handler, lib, locale, model, script, service, setting, template, uistatic,
} from './common';
const logger = new Logger('loader/worker');
const detail = cac().parse().options.loaderDetail;

@ -1,7 +1,7 @@
import graphql from 'graphql';
import { typeDefs, resolvers } from 'graphql-scalars';
import { Handler, Route } from '../service/server';
import { resolvers, typeDefs } from 'graphql-scalars';
import * as bus from '../service/bus';
import { Handler, Route } from '../service/server';
const types: Record<string, Record<string, string>> = {};
const unions: Record<string, string> = {};

@ -1,31 +1,31 @@
import AdmZip from 'adm-zip';
import { intersection } from 'lodash';
import { lookup } from 'mime-types';
import moment from 'moment-timezone';
import { ObjectID } from 'mongodb';
import AdmZip from 'adm-zip';
import { Time } from '@hydrooj/utils/lib/utils';
import { lookup } from 'mime-types';
import { intersection } from 'lodash';
import {
ContestNotLiveError, ValidationError, ProblemNotFoundError,
ContestNotAttendedError, PermissionError, BadRequestError,
ContestNotFoundError, InvalidTokenError, RecordNotFoundError,
} from '../error';
BadRequestError,
ContestNotAttendedError, ContestNotFoundError, ContestNotLiveError, InvalidTokenError, PermissionError, ProblemNotFoundError,
RecordNotFoundError,
ValidationError } from '../error';
import {
ProblemDoc, Tdoc, User, DomainDoc,
} from '../interface';
DomainDoc,
ProblemDoc, Tdoc, User } from '../interface';
import paginate from '../lib/paginate';
import { PERM, PRIV } from '../model/builtin';
import * as contest from '../model/contest';
import * as system from '../model/system';
import * as document from '../model/document';
import problem from '../model/problem';
import domain from '../model/domain';
import message from '../model/message';
import problem from '../model/problem';
import record from '../model/record';
import * as system from '../model/system';
import user from '../model/user';
import message from '../model/message';
import {
Route, Handler, Types, param,
} from '../service/server';
import * as bus from '../service/bus';
import {
Handler, param,
Route, Types } from '../service/server';
import storage from '../service/storage';
export class ContestListHandler extends Handler {

@ -1,17 +1,17 @@
import { ObjectID } from 'mongodb';
import { isSafeInteger } from 'lodash';
import { ObjectID } from 'mongodb';
import { DiscussionNotFoundError, DocumentNotFoundError, PermissionError } from '../error';
import { DiscussionReplyDoc, DiscussionDoc, DiscussionTailReplyDoc } from '../interface';
import { DiscussionDoc, DiscussionReplyDoc, DiscussionTailReplyDoc } from '../interface';
import paginate from '../lib/paginate';
import * as system from '../model/system';
import user from '../model/user';
import * as oplog from '../model/oplog';
import { PERM, PRIV } from '../model/builtin';
import * as discussion from '../model/discussion';
import * as document from '../model/document';
import { PERM, PRIV } from '../model/builtin';
import * as oplog from '../model/oplog';
import * as system from '../model/system';
import user from '../model/user';
import {
Route, Handler, Types, param,
} from '../service/server';
Handler, param,
Route, Types } from '../service/server';
export const typeMapper = {
problem: document.TYPE_PROBLEM,

@ -1,24 +1,24 @@
import moment from 'moment-timezone';
import { Dictionary } from 'lodash';
import moment from 'moment-timezone';
import {
RoleAlreadyExistError, ValidationError, DomainJoinForbiddenError,
DomainJoinAlreadyMemberError, InvalidJoinInvitationCodeError,
} from '../error';
import { log2 } from '../utils';
DomainJoinAlreadyMemberError, DomainJoinForbiddenError,
InvalidJoinInvitationCodeError,
RoleAlreadyExistError, ValidationError } from '../error';
import type { DomainDoc } from '../interface';
import user from '../model/user';
import domain from '../model/domain';
import * as discussion from '../model/discussion';
import * as system from '../model/system';
import { DOMAIN_SETTINGS, DOMAIN_SETTINGS_BY_KEY } from '../model/setting';
import avatar from '../lib/avatar';
import paginate from '../lib/paginate';
import {
DEFAULT_NODES, PERM, PERMS_BY_FAMILY, PRIV,
} from '../model/builtin';
import avatar from '../lib/avatar';
import paginate from '../lib/paginate';
import * as discussion from '../model/discussion';
import domain from '../model/domain';
import { DOMAIN_SETTINGS, DOMAIN_SETTINGS_BY_KEY } from '../model/setting';
import * as system from '../model/system';
import user from '../model/user';
import {
Route, Handler, Types, param, query, post,
} from '../service/server';
Handler, param, post,
query, Route, Types } from '../service/server';
import { log2 } from '../utils';
class DomainRankHandler extends Handler {
@query('page', Types.PositiveInt, true)

@ -1,32 +1,32 @@
import { ObjectID } from 'mongodb';
import yaml from 'js-yaml';
import { ObjectID } from 'mongodb';
import {
VerifyPasswordError, UserAlreadyExistError, InvalidTokenError,
NotFoundError, UserNotFoundError, PermissionError,
DomainAlreadyExistsError, ValidationError, BlacklistedError,
} from '../error';
import { MessageDoc, Setting, DomainDoc } from '../interface';
import * as bus from '../service/bus';
import {
Route, Connection, Handler, ConnectionHandler, param, Types,
} from '../service/server';
import { md5 } from '../lib/crypto';
import { isPassword, isEmail, isDomainId } from '../lib/validator';
BlacklistedError,
DomainAlreadyExistsError, InvalidTokenError,
NotFoundError, PermissionError,
UserAlreadyExistError, UserNotFoundError, ValidationError, VerifyPasswordError } from '../error';
import { DomainDoc, MessageDoc, Setting } from '../interface';
import avatar from '../lib/avatar';
import { md5 } from '../lib/crypto';
import * as mail from '../lib/mail';
import { isDomainId, isEmail, isPassword } from '../lib/validator';
import BlackListModel from '../model/blacklist';
import { PERM, PRIV } from '../model/builtin';
import * as contest from '../model/contest';
import message from '../model/message';
import * as discussion from '../model/discussion';
import * as document from '../model/document';
import * as system from '../model/system';
import user from '../model/user';
import * as setting from '../model/setting';
import domain from '../model/domain';
import * as discussion from '../model/discussion';
import message from '../model/message';
import ProblemModel from '../model/problem';
import * as setting from '../model/setting';
import * as system from '../model/system';
import token from '../model/token';
import * as training from '../model/training';
import { PERM, PRIV } from '../model/builtin';
import BlackListModel from '../model/blacklist';
import ProblemModel from '../model/problem';
import user from '../model/user';
import * as bus from '../service/bus';
import {
Connection, ConnectionHandler, Handler, param, Route, Types,
} from '../service/server';
const { geoip, useragent } = global.Hydro.lib;

@ -1,32 +1,32 @@
import AdmZip from 'adm-zip';
import yaml from 'js-yaml';
import { intersection } from 'lodash';
import { lookup } from 'mime-types';
import moment from 'moment-timezone';
import { ObjectID } from 'mongodb';
import AdmZip from 'adm-zip';
import { Time } from '@hydrooj/utils/lib/utils';
import { lookup } from 'mime-types';
import { intersection } from 'lodash';
import {
ValidationError, HomeworkNotLiveError, ProblemNotFoundError,
HomeworkNotAttendedError, BadRequestError,
} from '../error';
import {
PenaltyRules, Tdoc, ProblemDoc, User, DomainDoc,
} from '../interface';
BadRequestError,
HomeworkNotAttendedError, HomeworkNotLiveError, ProblemNotFoundError,
ValidationError } from '../error';
import {
Route, Handler, Types, param,
} from '../service/server';
import * as bus from '../service/bus';
import domain from '../model/domain';
DomainDoc,
PenaltyRules, ProblemDoc, Tdoc, User } from '../interface';
import paginate from '../lib/paginate';
import { PERM, PRIV, STATUS } from '../model/builtin';
import user from '../model/user';
import * as system from '../model/system';
import * as contest from '../model/contest';
import * as discussion from '../model/discussion';
import * as document from '../model/document';
import domain from '../model/domain';
import problem from '../model/problem';
import record from '../model/record';
import storage from '../model/storage';
import * as document from '../model/document';
import paginate from '../lib/paginate';
import * as system from '../model/system';
import user from '../model/user';
import * as bus from '../service/bus';
import {
Handler, param,
Route, Types } from '../service/server';
const validatePenaltyRules = (input: string) => yaml.load(input);
const convertPenaltyRules = validatePenaltyRules;

@ -1,27 +1,27 @@
/* eslint-disable no-await-in-loop */
import fs from 'fs-extra';
import path from 'path';
import os from 'os';
import assert from 'assert';
import superagent from 'superagent';
import { filter } from 'lodash';
import os from 'os';
import path from 'path';
import { PassThrough } from 'stream';
import AdmZip from 'adm-zip';
import fs from 'fs-extra';
import yaml from 'js-yaml';
import { filter } from 'lodash';
import superagent from 'superagent';
import { noop } from '@hydrooj/utils/lib/utils';
import { ValidationError, RemoteOnlineJudgeError } from '../error';
import { Logger } from '../logger';
import { RemoteOnlineJudgeError, ValidationError } from '../error';
import type { ContentNode, ProblemConfigFile, SubtaskConfig } from '../interface';
import { buildContent } from '../lib/content';
import download from '../lib/download';
import { ProblemAdd } from '../lib/ui';
import { isPid, parsePid } from '../lib/validator';
import { Logger } from '../logger';
import { PERM, PRIV } from '../model/builtin';
import problem, { ProblemDoc } from '../model/problem';
import TaskModel from '../model/task';
import { PERM, PRIV } from '../model/builtin';
import {
Route, Handler, Types, post,
} from '../service/server';
import { isPid, parsePid } from '../lib/validator';
import download from '../lib/download';
import { buildContent } from '../lib/content';
import { ProblemAdd } from '../lib/ui';
Handler, post,
Route, Types } from '../service/server';
const RE_SYZOJ = /(https?):\/\/([^/]+)\/(problem|p)\/([0-9]+)\/?/i;
const logger = new Logger('import.syzoj');

@ -1,22 +1,22 @@
import { ObjectID } from 'mongodb';
import { JudgeResultBody, RecordDoc, TestCase } from '../interface';
import { sleep } from '../utils';
import { Logger } from '../logger';
import difficultyAlgorithm from '../lib/difficulty';
import record from '../model/record';
import problem from '../model/problem';
import * as setting from '../model/setting';
import { Logger } from '../logger';
import * as builtin from '../model/builtin';
import * as contest from '../model/contest';
import domain from '../model/domain';
import task from '../model/task';
import * as system from '../model/system';
import problem from '../model/problem';
import record from '../model/record';
import * as setting from '../model/setting';
import storage from '../model/storage';
import * as system from '../model/system';
import task from '../model/task';
import * as bus from '../service/bus';
import { updateJudge } from '../service/monitor';
import {
Route, Handler, Connection, ConnectionHandler, post, Types,
Connection, ConnectionHandler, Handler, post, Route, Types,
} from '../service/server';
import { updateJudge } from '../service/monitor';
import { sleep } from '../utils';
const logger = new Logger('judge');

@ -1,22 +1,22 @@
import { inspect } from 'util';
import * as yaml from 'js-yaml';
import * as judge from './judge';
import { ValidationError } from '../error';
import * as check from '../check';
import { ValidationError } from '../error';
import {
isEmail, isPassword,
isUname, validate } from '../lib/validator';
import { Logger } from '../logger';
import { PRIV, STATUS } from '../model/builtin';
import domain from '../model/domain';
import record from '../model/record';
import * as setting from '../model/setting';
import * as system from '../model/system';
import user from '../model/user';
import { STATUS, PRIV } from '../model/builtin';
import record from '../model/record';
import domain from '../model/domain';
import {
Route, Connection, Handler, ConnectionHandler, param, Types,
} from '../service/server';
import * as bus from '../service/bus';
import {
validate, isEmail, isUname, isPassword,
} from '../lib/validator';
Connection, ConnectionHandler, Handler, param, Route, Types,
} from '../service/server';
import * as judge from './judge';
const logger = new Logger('manage');

@ -4,14 +4,14 @@ import { lookup } from 'mime-types';
import {
BadRequestError, ForbiddenError, ValidationError,
} from '../error';
import { sortFiles } from '../utils';
import { PRIV } from '../model/builtin';
import storage from '../model/storage';
import * as system from '../model/system';
import user from '../model/user';
import {
Route, Handler, Types, param, post,
} from '../service/server';
Handler, param, post,
Route, Types } from '../service/server';
import { sortFiles } from '../utils';
class CheckInHandler extends Handler {
async prepare() {

@ -2,7 +2,7 @@
/* eslint-disable class-methods-use-this */
import { NotFoundError } from '../error';
import {
Route, Handler, param, Types,
Handler, param, Route, Types,
} from '../service/server';
class NotFoundHandler extends Handler {

@ -1,34 +1,34 @@
import { isSafeInteger, flatten, intersection } from 'lodash';
import { FilterQuery, ObjectID } from 'mongodb';
import AdmZip from 'adm-zip';
import { sortFiles } from '@hydrooj/utils/lib/utils';
import { flatten, intersection, isSafeInteger } from 'lodash';
import { lookup } from 'mime-types';
import { registerResolver, registerValue } from './api';
import { FilterQuery, ObjectID } from 'mongodb';
import { sortFiles } from '@hydrooj/utils/lib/utils';
import {
NoProblemError, PermissionError, ValidationError,
SolutionNotFoundError, ProblemNotFoundError, BadRequestError,
BadRequestError,
ForbiddenError,
NoProblemError, PermissionError, ProblemNotFoundError, SolutionNotFoundError, ValidationError,
} from '../error';
import {
ProblemDoc, User, ProblemStatusDoc,
} from '../interface';
ProblemDoc, ProblemStatusDoc,
User } from '../interface';
import difficultyAlgorithm from '../lib/difficulty';
import paginate from '../lib/paginate';
import { isPid, parsePid as convertPid } from '../lib/validator';
import difficultyAlgorithm from '../lib/difficulty';
import * as system from '../model/system';
import { PERM, PRIV } from '../model/builtin';
import * as contest from '../model/contest';
import * as document from '../model/document';
import domain from '../model/domain';
import problem from '../model/problem';
import record from '../model/record';
import domain from '../model/domain';
import user from '../model/user';
import * as document from '../model/document';
import * as contest from '../model/contest';
import solution from '../model/solution';
import { PERM, PRIV } from '../model/builtin';
import storage from '../model/storage';
import * as system from '../model/system';
import user from '../model/user';
import * as bus from '../service/bus';
import {
Route, Handler, Types, param, post, route, query,
} from '../service/server';
Handler, param, post, query,
Route, route, Types } from '../service/server';
import { registerResolver, registerValue } from './api';
export const parseCategory = (value: string) => flatten(value.replace(//g, ',').split(',')).map((e) => e.trim());
export const parsePid = (value: string) => (isSafeInteger(value) ? +value : value);

@ -1,23 +1,23 @@
import { FilterQuery, ObjectID } from 'mongodb';
import { pick } from 'lodash';
import { postJudge } from './judge';
import { FilterQuery, ObjectID } from 'mongodb';
import {
ContestNotAttendedError, ContestNotFoundError, PermissionError,
ProblemNotFoundError, RecordNotFoundError, UserNotFoundError,
} from '../error';
import { buildProjection } from '../utils';
import { RecordDoc } from '../interface';
import { PERM, STATUS, PRIV } from '../model/builtin';
import * as system from '../model/system';
import { PERM, PRIV, STATUS } from '../model/builtin';
import * as contest from '../model/contest';
import problem from '../model/problem';
import record from '../model/record';
import * as contest from '../model/contest';
import user from '../model/user';
import * as system from '../model/system';
import TaskModel from '../model/task';
import user from '../model/user';
import * as bus from '../service/bus';
import {
Route, Handler, Connection, ConnectionHandler, Types, param,
} from '../service/server';
Connection, ConnectionHandler, Handler, param,
Route, Types } from '../service/server';
import { buildProjection } from '../utils';
import { postJudge } from './judge';
class RecordListHandler extends Handler {
@param('page', Types.PositiveInt, true)

@ -1,11 +1,11 @@
import { PRIV } from '../model/builtin';
import RecordModel from '../model/record';
import DomainModel from '../model/domain';
import * as DocumentModel from '../model/document';
import db from '../service/db';
import * as bus from '../service/bus';
import { Route, Handler } from '../service/server';
import DomainModel from '../model/domain';
import RecordModel from '../model/record';
import UserModel from '../model/user';
import * as bus from '../service/bus';
import db from '../service/db';
import { Handler, Route } from '../service/server';
const coll = db.collection('status');

@ -1,19 +1,19 @@
import assert from 'assert';
import { FilterQuery, ObjectID } from 'mongodb';
import { ProblemNotFoundError, ValidationError } from '../error';
import { Tdoc, TrainingDoc } from '../interface';
import { ValidationError, ProblemNotFoundError } from '../error';
import { isContent, isDescription } from '../lib/validator';
import paginate from '../lib/paginate';
import * as system from '../model/system';
import { isContent, isDescription } from '../lib/validator';
import { PERM, PRIV } from '../model/builtin';
import problem from '../model/problem';
import * as builtin from '../model/builtin';
import problem from '../model/problem';
import * as system from '../model/system';
import * as training from '../model/training';
import user from '../model/user';
import * as bus from '../service/bus';
import {
Route, Handler, Types, param,
} from '../service/server';
Handler, param,
Route, Types } from '../service/server';
async function _parseDagJson(domainId: string, _dag: string): Promise<Tdoc['dag']> {
const parsed = [];

@ -1,27 +1,27 @@
import moment from 'moment-timezone';
import { registerResolver, registerValue } from './api';
import {
UserAlreadyExistError, InvalidTokenError, VerifyPasswordError,
UserNotFoundError, SystemError, BlacklistedError,
UserFacingError, LoginError,
BlacklistedError,
InvalidTokenError, LoginError,
SystemError, UserAlreadyExistError, UserFacingError, UserNotFoundError, VerifyPasswordError,
} from '../error';
import { User } from '../interface';
import {
Route, Handler, Types, param, post,
} from '../service/server';
import user from '../model/user';
import avatar from '../lib/avatar';
import { sendMail } from '../lib/mail';
import paginate from '../lib/paginate';
import { isEmail, isPassword, isUname } from '../lib/validator';
import BlackListModel from '../model/blacklist';
import { PERM, PRIV } from '../model/builtin';
import oauth from '../model/oauth';
import token from '../model/token';
import record from '../model/record';
import problem, { ProblemDoc } from '../model/problem';
import task from '../model/task';
import record from '../model/record';
import * as system from '../model/system';
import { PERM, PRIV } from '../model/builtin';
import BlackListModel from '../model/blacklist';
import { isEmail, isPassword, isUname } from '../lib/validator';
import { sendMail } from '../lib/mail';
import paginate from '../lib/paginate';
import avatar from '../lib/avatar';
import task from '../model/task';
import token from '../model/token';
import user from '../model/user';
import {
Handler, param, post,
Route, Types } from '../service/server';
import { registerResolver, registerValue } from './api';
registerValue('User', [
['_id', 'Int!'],

@ -1,9 +1,9 @@
import { ItemBucketMetadata } from 'minio';
import type { Readable, Writable } from 'stream';
import type { Cursor, ObjectID } from 'mongodb';
import type fs from 'fs';
import type { Dictionary, NumericDictionary } from 'lodash';
import type * as Koa from 'koa';
import type { Dictionary, NumericDictionary } from 'lodash';
import type { ItemBucketMetadata } from 'minio';
import type { Cursor, ObjectID } from 'mongodb';
import type { Readable, Writable } from 'stream';
import type { ProblemDoc } from './model/problem';
type document = typeof import('./model/document');

@ -1,5 +1,5 @@
import superagent, { SuperAgentRequest } from 'superagent';
import fs from 'fs';
import superagent, { SuperAgentRequest } from 'superagent';
async function _download(url: string, path: string, retry: number) {
const w = fs.createWriteStream(path);

@ -1,6 +1,6 @@
import AnsiUp from 'ansi_up';
import { ObjectID } from 'mongodb';
import { size, formatSeconds } from '@hydrooj/utils/lib/utils';
import { formatSeconds, size } from '@hydrooj/utils/lib/utils';
export { size, formatSeconds } from '@hydrooj/utils/lib/utils';

@ -1,5 +1,5 @@
import readYamlCases from '@hydrooj/utils/lib/cases';
import { load } from 'js-yaml';
import readYamlCases from '@hydrooj/utils/lib/cases';
import type { ProblemConfig, ProblemConfigFile } from '../interface';
export async function parseConfig(config: string | ProblemConfigFile = {}) {

@ -1,4 +1,4 @@
/* eslint-disable import/no-dynamic-require */
/* eslint-disable simple-import-sort/imports */
/* eslint-disable no-await-in-loop */
/* eslint-disable no-eval */
import 'reflect-metadata';
@ -50,6 +50,6 @@ export async function load() {
}
export async function loadCli() {
require('./entry/cli').load();
await require('./entry/cli').load();
process.kill(process.pid, 'SIGINT');
}

@ -1,5 +1,5 @@
import { nanoid } from 'nanoid';
import { format, inspect, InspectOptions } from 'util';
import { nanoid } from 'nanoid';
const colors = [
20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62,

@ -1,7 +1,7 @@
import moment from 'moment';
import { ArgMethod } from '../utils';
import db from '../service/db';
import * as bus from '../service/bus';
import db from '../service/db';
import { ArgMethod } from '../utils';
const coll = db.collection('blacklist');

@ -7,10 +7,10 @@
* e.g.: object?.property
*/
import {
STATUS, STATUS_TEXTS, STATUS_CODES,
USER_GENDER_MALE, USER_GENDER_FEMALE, USER_GENDER_OTHER,
USER_GENDER_ICONS, USER_GENDERS, USER_GENDER_RANGE,
} from '@hydrooj/utils/lib/status';
STATUS, STATUS_CODES,
STATUS_TEXTS, USER_GENDER_FEMALE, USER_GENDER_ICONS, USER_GENDER_MALE, USER_GENDER_OTHER,
USER_GENDER_RANGE,
USER_GENDERS } from '@hydrooj/utils/lib/status';
export * from '@hydrooj/utils/lib/status';

@ -1,20 +1,20 @@
import { ObjectID, FilterQuery } from 'mongodb';
import user from './user';
import problem from './problem';
import * as document from './document';
import { PERM, STATUS } from './builtin';
import { FilterQuery, ObjectID } from 'mongodb';
import {
ValidationError, ContestNotFoundError, ContestAlreadyAttendedError,
ContestNotAttendedError, ContestScoreboardHiddenError,
} from '../error';
ContestAlreadyAttendedError,
ContestNotAttendedError, ContestNotFoundError, ContestScoreboardHiddenError,
ValidationError } from '../error';
import {
ProblemId, ContestRule, ContestRules, ProblemDict,
ScoreboardNode, ScoreboardRow, Tdoc,
ContestRule, ContestRules, ProblemDict,
ProblemId, ScoreboardNode, ScoreboardRow, Tdoc,
Udict,
} from '../interface';
import * as bus from '../service/bus';
import * as misc from '../lib/misc';
import ranked from '../lib/rank';
import * as bus from '../service/bus';
import { PERM, STATUS } from './builtin';
import * as document from './document';
import problem from './problem';
import user from './user';
type Type = 30 | 60;

@ -1,16 +1,16 @@
import { FilterQuery, ObjectID } from 'mongodb';
import { omit } from 'lodash';
import moment from 'moment';
import problem from './problem';
import * as contest from './contest';
import * as training from './training';
import * as document from './document';
import TaskModel from './task';
import { FilterQuery, ObjectID } from 'mongodb';
import { DiscussionNodeNotFoundError, DocumentNotFoundError } from '../error';
import { DiscussionReplyDoc, DiscussionTailReplyDoc, Document } from '../interface';
import { buildProjection } from '../utils';
import { NumberKeys } from '../typeutils';
import * as bus from '../service/bus';
import { NumberKeys } from '../typeutils';
import { buildProjection } from '../utils';
import * as contest from './contest';
import * as document from './document';
import problem from './problem';
import TaskModel from './task';
import * as training from './training';
export interface DiscussionDoc extends Document { }
export namespace DiscussionDoc {

@ -1,16 +1,16 @@
/* eslint-disable object-curly-newline */
import assert from 'assert';
import {
ObjectID, Cursor, FilterQuery, UpdateQuery, OnlyFieldsOfType,
} from 'mongodb';
Cursor, FilterQuery, ObjectID, OnlyFieldsOfType,
UpdateQuery } from 'mongodb';
import {
ProblemDoc, DiscussionDoc, DiscussionReplyDoc, Tdoc, TrainingDoc,
ProblemStatusDoc, Content,
Content,
DiscussionDoc, DiscussionReplyDoc, ProblemDoc, ProblemStatusDoc, Tdoc, TrainingDoc,
} from '../interface';
import { buildProjection } from '../utils';
import { NumberKeys, ArrayKeys, Projection, MaybeArray } from '../typeutils';
import db from '../service/db';
import * as bus from '../service/bus';
import db from '../service/db';
import { ArrayKeys, MaybeArray, NumberKeys, Projection } from '../typeutils';
import { buildProjection } from '../utils';
type DocID = ObjectID | string | number;
@ -234,7 +234,7 @@ export async function setSub<T extends keyof DocType, K extends ArrayKeys<DocTyp
domainId: string, docType: T, docId: DocType[T]['docId'],
key: K, subId: DocType[T][K][0]['_id'], args: Partial<DocType[T][K][0]>,
): Promise<DocType[T]> {
const $set = {};
const $set: Record<string, any> = {};
for (const k in args) $set[`${key}.$.${k}`] = args[k];
const res = await coll.findOneAndUpdate(
{

@ -1,11 +1,11 @@
import { Dictionary } from 'lodash';
import { FilterQuery } from 'mongodb';
import { BUILTIN_ROLES, PRIV } from './builtin';
import { DomainDoc } from '../interface';
import { ArgMethod } from '../utils';
import { MaybeArray, NumberKeys } from '../typeutils';
import * as bus from '../service/bus';
import db from '../service/db';
import { MaybeArray, NumberKeys } from '../typeutils';
import { ArgMethod } from '../utils';
import { BUILTIN_ROLES, PRIV } from './builtin';
import UserModel, { deleteUserCache } from './user';
const coll = db.collection('domain');

@ -1,9 +1,9 @@
import { FilterQuery, ObjectID } from 'mongodb';
import user from './user';
import { MessageDoc } from '../interface';
import { ArgMethod } from '../utils';
import db from '../service/db';
import * as bus from '../service/bus';
import db from '../service/db';
import { ArgMethod } from '../utils';
import user from './user';
const coll = db.collection('message');

@ -1,23 +1,23 @@
import { ObjectID, FilterQuery } from 'mongodb';
import {
Dictionary, escapeRegExp, flatten, groupBy, pick,
} from 'lodash';
import { streamToBuffer } from '@hydrooj/utils/lib/utils';
import { FilterQuery, ObjectID } from 'mongodb';
import type { Readable } from 'stream';
import * as document from './document';
import { STATUS } from './builtin';
import domain from './domain';
import storage from './storage';
import { buildProjection } from '../utils';
import { streamToBuffer } from '@hydrooj/utils/lib/utils';
import { ProblemNotFoundError, ValidationError } from '../error';
import type {
ProblemStatusDoc, ProblemDict, Document, ProblemId, DomainDoc,
} from '../interface';
Document, DomainDoc,
ProblemDict, ProblemId, ProblemStatusDoc } from '../interface';
import { parseConfig } from '../lib/testdataConfig';
import * as bus from '../service/bus';
import {
ArrayKeys, MaybeArray, NumberKeys, Projection,
} from '../typeutils';
import { ProblemNotFoundError, ValidationError } from '../error';
import * as bus from '../service/bus';
import { parseConfig } from '../lib/testdataConfig';
import { buildProjection } from '../utils';
import { STATUS } from './builtin';
import * as document from './document';
import domain from './domain';
import storage from './storage';
export interface ProblemDoc extends Document { }
export type Field = keyof ProblemDoc;

@ -1,22 +1,22 @@
/* eslint-disable object-curly-newline */
import {
ObjectID, Collection, UpdateQuery,
PushOperator, MatchKeysAndValues, OnlyFieldsOfType,
FilterQuery,
} from 'mongodb';
import { omit, sum } from 'lodash';
import moment from 'moment';
import { STATUS } from './builtin';
import task from './task';
import problem from './problem';
import {
RecordDoc, ContestInfo, ProblemConfigFile, ExternalProblemId, FileInfo,
} from '../interface';
Collection, FilterQuery,
MatchKeysAndValues, ObjectID, OnlyFieldsOfType,
PushOperator, UpdateQuery,
} from 'mongodb';
import { ProblemNotFoundError } from '../error';
import { ArgMethod, buildProjection, Time } from '../utils';
import { MaybeArray } from '../typeutils';
import {
ContestInfo, ExternalProblemId, FileInfo,
ProblemConfigFile, RecordDoc } from '../interface';
import * as bus from '../service/bus';
import db from '../service/db';
import { MaybeArray } from '../typeutils';
import { ArgMethod, buildProjection, Time } from '../utils';
import { STATUS } from './builtin';
import problem from './problem';
import task from './task';
class RecordModel {
static coll: Collection<RecordDoc> = db.collection('record');

@ -1,14 +1,14 @@
/* eslint-disable max-len */
/* eslint-disable no-await-in-loop */
import moment from 'moment-timezone';
import { Dictionary } from 'lodash';
import yaml from 'js-yaml';
import { retry } from '@hydrooj/utils/lib/utils';
import { Dictionary } from 'lodash';
import moment from 'moment-timezone';
import { parseLang } from '@hydrooj/utils/lib/lang';
import * as builtin from './builtin';
import { retry } from '@hydrooj/utils/lib/utils';
import { Setting as _Setting } from '../interface';
import { Logger } from '../logger';
import * as bus from '../service/bus';
import * as builtin from './builtin';
type SettingDict = Dictionary<_Setting>;
@ -208,7 +208,6 @@ SystemSetting(
Setting('setting_storage', 'installid', String.random(64), 'text', 'installid', 'Installation ID', FLAG_HIDDEN | FLAG_DISABLED),
);
// eslint-disable-next-line import/no-mutable-exports
export let langs = {};
bus.once('app/started', async () => {

@ -1,7 +1,7 @@
import { ObjectID } from 'mongodb';
import * as document from './document';
import { SolutionNotFoundError } from '../error';
import * as bus from '../service/bus';
import * as document from './document';
class SolutionModel {
static add(domainId: string, pid: number, owner: number, content: string) {

@ -1,14 +1,14 @@
import { extname } from 'path';
import { escapeRegExp } from 'lodash';
import { ItemBucketMetadata } from 'minio';
import { nanoid } from 'nanoid';
import { lookup } from 'mime-types';
import { ItemBucketMetadata } from 'minio';
import moment from 'moment';
import { extname } from 'path';
import { nanoid } from 'nanoid';
import type { Readable } from 'stream';
import TaskModel from './task';
import storage from '../service/storage';
import * as bus from '../service/bus';
import db from '../service/db';
import storage from '../service/storage';
import TaskModel from './task';
export class StorageModel {
static coll = db.collection('storage');

@ -1,8 +1,8 @@
import { SYSTEM_SETTINGS } from './setting';
import { NumberKeys } from '../typeutils';
import { SystemKeys } from '../interface';
import db from '../service/db';
import * as bus from '../service/bus';
import db from '../service/db';
import { NumberKeys } from '../typeutils';
import { SYSTEM_SETTINGS } from './setting';
const coll = db.collection('system');
const cache: Record<string, any> = {};

@ -1,11 +1,11 @@
import moment from 'moment-timezone';
import { hostname } from 'os';
import moment from 'moment-timezone';
import { FilterQuery, ObjectID } from 'mongodb';
import { sleep } from '@hydrooj/utils/lib/utils';
import { BaseService, Task } from '../interface';
import { Logger } from '../logger';
import db from '../service/db';
import * as bus from '../service/bus';
import db from '../service/db';
const logger = new Logger('model/task');
const coll = db.collection('task');

@ -1,8 +1,8 @@
import { FilterQuery } from 'mongodb';
import { ArgMethod } from '../utils';
import { TokenDoc } from '../interface';
import db from '../service/db';
import * as bus from '../service/bus';
import db from '../service/db';
import { ArgMethod } from '../utils';
class TokenModel {
static coll = db.collection('token');

@ -1,8 +1,8 @@
import { FilterQuery, ObjectID } from 'mongodb';
import { flatten } from 'lodash';
import * as document from './document';
import { TrainingNotFoundError, TrainingAlreadyEnrollError } from '../error';
import { FilterQuery, ObjectID } from 'mongodb';
import { TrainingAlreadyEnrollError, TrainingNotFoundError } from '../error';
import { TrainingDoc, TrainingNode } from '../interface';
import * as document from './document';
export function getStatus(domainId: string, tid: ObjectID, uid: number) {
return document.getStatus(domainId, document.TYPE_TRAINING, tid, uid);

@ -1,21 +1,21 @@
import { Collection } from 'mongodb';
import LRU from 'lru-cache';
import { escapeRegExp, pick } from 'lodash';
import * as system from './system';
import token from './token';
import * as setting from './setting';
import domain from './domain';
import { PERM, PRIV } from './builtin';
import { ArgMethod } from '../utils';
import { UserNotFoundError, UserAlreadyExistError, LoginError } from '../error';
import LRU from 'lru-cache';
import { Collection } from 'mongodb';
import { LoginError, UserAlreadyExistError, UserNotFoundError } from '../error';
import {
User as _User, Udoc, Udict, FileInfo,
} from '../interface';
import { Value } from '../typeutils';
import { Logger } from '../logger';
FileInfo,
Udict, Udoc, User as _User } from '../interface';
import pwhash from '../lib/hash.hydro';
import db from '../service/db';
import { Logger } from '../logger';
import * as bus from '../service/bus';
import db from '../service/db';
import { Value } from '../typeutils';
import { ArgMethod } from '../utils';
import { PERM, PRIV } from './builtin';
import domain from './domain';
import * as setting from './setting';
import * as system from './system';
import token from './token';
const coll: Collection<Udoc> = db.collection('user');
const logger = new Logger('model/user');

@ -1,13 +1,14 @@
/* eslint-disable no-await-in-loop */
import { FilterQuery } from 'mongodb';
import type {
DomainDoc, Udoc, ProblemStatusDoc, RecordDoc,
DomainDoc, ProblemStatusDoc, RecordDoc,
Udoc,
} from './interface';
import domain from './model/domain';
import * as document from './model/document';
import user from './model/user';
import domain from './model/domain';
import problem, { Field, ProblemDoc } from './model/problem';
import RecordModel from './model/record';
import user from './model/user';
export async function iterateAllDomain(cb: (ddoc: DomainDoc, current?: number, total?: number) => Promise<any>) {
const ddocs = await domain.getMulti().toArray();

@ -1,9 +1,9 @@
/* eslint-disable @typescript-eslint/no-use-before-define */
import { ObjectID } from 'mongodb';
import * as document from '../model/document';
import blacklist from '../model/blacklist';
import * as discussion from '../model/discussion';
import * as document from '../model/document';
import user from '../model/user';
import blacklist from '../model/blacklist';
import db from '../service/db';
export const description = 'Add blacklist by ip, uid';

@ -1,6 +1,6 @@
import { PRIV } from '../model/builtin';
import user from '../model/user';
import db from '../service/db';
import { PRIV } from '../model/builtin';
export const description = 'Delete a user';

@ -1,7 +1,7 @@
/* eslint-disable no-await-in-loop */
import db from '../service/db';
import { STATUS } from '../model/builtin';
import * as document from '../model/document';
import db from '../service/db';
export const description = 'Recalculates nSubmit and nAccept in problem status.';

@ -1,16 +1,16 @@
/* eslint-disable no-await-in-loop */
import { unionWith, NumericDictionary } from 'lodash';
import { ObjectID, FilterQuery } from 'mongodb';
import { Tdoc, ProblemDoc, Udoc } from '../interface';
import db from '../service/db';
import domain from '../model/domain';
import { NumericDictionary, unionWith } from 'lodash';
import { FilterQuery, ObjectID } from 'mongodb';
import { ProblemDoc, Tdoc, Udoc } from '../interface';
import paginate from '../lib/paginate';
import rating from '../lib/rating';
import { PRIV, STATUS } from '../model/builtin';
import * as contest from '../model/contest';
import domain from '../model/domain';
import problem from '../model/problem';
import UserModel from '../model/user';
import record from '../model/record';
import { PRIV, STATUS } from '../model/builtin';
import rating from '../lib/rating';
import paginate from '../lib/paginate';
import UserModel from '../model/user';
import db from '../service/db';
export const description = 'Calculate rp of a domain, or all domains';

@ -1,7 +1,7 @@
// @ts-nocheck
import { Collection, Db, MongoClient } from 'mongodb';
import { BaseService, Collections } from '../../interface';
import * as bus from '../bus';
import { Collections, BaseService } from '../../interface';
interface MongoConfig {
protocol?: string,

@ -3,16 +3,16 @@ import cac from 'cac';
import type {
Db, FilterQuery, ObjectID, OnlyFieldsOfType,
} from 'mongodb';
import type { Handler } from './server';
import { Logger } from '../logger';
import type {
MessageDoc, ProblemDoc, RecordDoc,
TrainingDoc, User, DiscussionDoc,
DomainDoc, FileInfo, Tdoc,
} from '../interface';
import type { DocType } from '../model/document';
import type { ProblemSolutionHandler } from '../handler/problem';
import type { UserRegisterHandler } from '../handler/user';
import type {
DiscussionDoc,
DomainDoc, FileInfo, MessageDoc, ProblemDoc, RecordDoc,
Tdoc,
TrainingDoc, User } from '../interface';
import { Logger } from '../logger';
import type { DocType } from '../model/document';
import type { Handler } from './server';
const _hooks: Record<keyof any, Array<(...args: any[]) => any>> = {};
const logger = new Logger('bus');

@ -1,6 +1,6 @@
import { Collection, Db, MongoClient } from 'mongodb';
import { BaseService, Collections } from '../interface';
import * as bus from './bus';
import { Collections, BaseService } from '../interface';
interface MongoConfig {
protocol?: string,

@ -1,11 +1,11 @@
import crypto from 'crypto';
import superagent from 'superagent';
import { dump } from 'js-yaml';
import * as sysinfo from '@hydrooj/utils/lib/sysinfo';
import superagent from 'superagent';
import type { StatusUpdate } from '@hydrooj/utils/lib/sysinfo';
import db from './db';
import * as bus from './bus';
import * as sysinfo from '@hydrooj/utils/lib/sysinfo';
import { Logger } from '../logger';
import * as bus from './bus';
import db from './db';
const coll = db.collection('status');
const logger = new Logger('monitor');

@ -1,43 +1,43 @@
import assert from 'assert';
import { PassThrough } from 'stream';
import { resolve } from 'path';
import os from 'os';
import { createHash } from 'crypto';
import http from 'http';
import moment from 'moment-timezone';
import {
isSafeInteger, Dictionary, filter, cloneDeep,
} from 'lodash';
import { ObjectID } from 'mongodb';
import os from 'os';
import { resolve } from 'path';
import { PassThrough } from 'stream';
import cac from 'cac';
import Cookies from 'cookies';
import Koa, { Context } from 'koa';
import Body from 'koa-body';
import Compress from 'koa-compress';
import Router from 'koa-router';
import proxy from 'koa-proxies';
import Router from 'koa-router';
import cache from 'koa-static-cache';
import {
cloneDeep,
Dictionary, filter, isSafeInteger } from 'lodash';
import moment from 'moment-timezone';
import { ObjectID } from 'mongodb';
import sockjs from 'sockjs';
import cac from 'cac';
import { createHash } from 'crypto';
import { parseMemoryMB } from '@hydrooj/utils/lib/utils';
import Cookies from 'cookies';
import * as bus from './bus';
import { errorMessage } from '../utils';
import { User, DomainDoc } from '../interface';
import { Logger } from '../logger';
import {
UserNotFoundError, BlacklistedError, PermissionError,
UserFacingError, ValidationError, PrivilegeError,
CsrfTokenError, InvalidOperationError, MethodNotAllowedError,
NotFoundError, HydroError, SystemError,
} from '../error';
import { isContent, isName, isTitle } from '../lib/validator';
BlacklistedError, CsrfTokenError, HydroError, InvalidOperationError, MethodNotAllowedError,
NotFoundError, PermissionError,
PrivilegeError,
SystemError,
UserFacingError, UserNotFoundError, ValidationError } from '../error';
import { DomainDoc, User } from '../interface';
import avatar from '../lib/avatar';
import user from '../model/user';
import { isContent, isName, isTitle } from '../lib/validator';
import { Logger } from '../logger';
import blacklist from '../model/blacklist';
import { PERM, PRIV } from '../model/builtin';
import domain from '../model/domain';
import * as opcount from '../model/opcount';
import * as system from '../model/system';
import blacklist from '../model/blacklist';
import token from '../model/token';
import * as opcount from '../model/opcount';
import { PERM, PRIV } from '../model/builtin';
import user from '../model/user';
import { errorMessage } from '../utils';
import * as bus from './bus';
const argv = cac().parse();
const logger = new Logger('server');
@ -702,11 +702,15 @@ async function handle(ctx, HandlerClass, checker) {
await bail('handler/init', h);
await bail(`handler/before-prepare/${HandlerClass.name.replace(/Handler$/, '')}`, h);
await bail('handler/before-prepare', h);
h.args.__prepare = Date.now();
if (h._prepare) await h._prepare(args);
if (h.prepare) await h.prepare(args);
h.args.__prepareDone = Date.now();
await bail(`handler/before/${HandlerClass.name.replace(/Handler$/, '')}`, h);
await bail('handler/before', h);
h.args.__method = Date.now();
if (h[method]) await h[method](args);
h.args.__methodDone = Date.now();
await bail(`handler/before-operation/${HandlerClass.name.replace(/Handler$/, '')}`, h);
await bail('handler/before-operation', h);
if (operation) await h[`post${operation}`](args);

@ -1,11 +1,11 @@
import { Readable } from 'stream';
import assert from 'assert';
import { Readable } from 'stream';
import { URL } from 'url';
import { Client, BucketItem, ItemBucketMetadata } from 'minio';
import { createReadStream } from 'fs-extra';
import { BucketItem, Client, ItemBucketMetadata } from 'minio';
import { Logger } from '../logger';
import { streamToBuffer } from '../utils';
import * as system from '../model/system';
import { streamToBuffer } from '../utils';
const logger = new Logger('storage');

@ -1,23 +1,23 @@
import * as interfaces from './interface';
import * as document from './model/document';
import user from './model/user';
import domain from './model/domain';
import problem from './model/problem';
import record from './model/record';
import task from './model/task';
import * as training from './model/training';
import blacklist from './model/blacklist';
import * as builtin from './model/builtin';
import * as contest from './model/contest';
import * as discussion from './model/discussion';
import * as document from './model/document';
import domain from './model/domain';
import message from './model/message';
import oauth from './model/oauth';
import * as opcount from './model/opcount';
import * as oplog from './model/oplog';
import * as system from './model/system';
import problem from './model/problem';
import record from './model/record';
import * as setting from './model/setting';
import solution from './model/solution';
import * as system from './model/system';
import task from './model/task';
import token from './model/token';
import message from './model/message';
import * as discussion from './model/discussion';
import * as contest from './model/contest';
import * as opcount from './model/opcount';
import * as training from './model/training';
import user from './model/user';
export const Interface = interfaces;

@ -1,34 +1,34 @@
/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable no-await-in-loop */
import { ObjectID, GridFSBucket } from 'mongodb';
import AdmZip from 'adm-zip';
import Queue from 'p-queue';
import yaml from 'js-yaml';
import { pick } from 'lodash';
import { convertIniConfig } from '@hydrooj/utils/lib/cases';
import { BucketItem } from 'minio';
import moment from 'moment';
import db from './service/db';
import { Progress } from './ui';
import { Logger } from './logger';
import { streamToBuffer } from './utils';
import {
iterateAllDomain, iterateAllProblem, iterateAllPsdoc, iterateAllUser,
} from './pipelineUtils';
import storage from './service/storage';
import { GridFSBucket, ObjectID } from 'mongodb';
import Queue from 'p-queue';
import { convertIniConfig } from '@hydrooj/utils/lib/cases';
import { buildContent } from './lib/content';
import difficultyAlgorithm from './lib/difficulty';
import problem from './model/problem';
import user from './model/user';
import { size } from './lib/misc';
import { Logger } from './logger';
import { PRIV, STATUS } from './model/builtin';
import * as contest from './model/contest';
import * as discussion from './model/discussion';
import domain from './model/domain';
import * as document from './model/document';
import * as system from './model/system';
import { PRIV, STATUS } from './model/builtin';
import domain from './model/domain';
import problem from './model/problem';
import RecordModel from './model/record';
import StorageModel from './model/storage';
import { size } from './lib/misc';
import { buildContent } from './lib/content';
import * as system from './model/system';
import user from './model/user';
import {
iterateAllDomain, iterateAllProblem, iterateAllPsdoc, iterateAllUser,
} from './pipelineUtils';
import db from './service/db';
import storage from './service/storage';
import { Progress } from './ui';
import { streamToBuffer } from './utils';
const logger = new Logger('upgrade');
type UpgradeScript = void | (() => Promise<boolean | void>);

@ -1,4 +1,5 @@
import 'hydrooj/src/loader';
import * as bus from 'hydrooj/src/service/bus';
jest.mock('hydrooj/src/service/db');

@ -1,4 +1,5 @@
import 'hydrooj/src/loader';
import { md5, sha1 } from 'hydrooj/src/lib/crypto';
import pwhash from 'hydrooj/src/lib/hash.hydro';

@ -1,4 +1,5 @@
import 'hydrooj/src/loader';
import * as validator from 'hydrooj/src/lib/validator';
describe('Validator', () => {

@ -1,4 +1,5 @@
import 'hydrooj/src/loader';
import { connect, dispose } from './db';
jest.setTimeout(30000);

@ -1,6 +1,7 @@
import 'hydrooj/src/loader';
import * as bus from 'hydrooj/src/service/bus';
import { PRIV } from 'hydrooj/src/model/builtin';
import * as bus from 'hydrooj/src/service/bus';
import { connect, dispose } from './db';
jest.setTimeout(30000);

@ -1,4 +1,5 @@
import 'hydrooj/src/loader';
import * as utils from 'hydrooj/src/utils';
describe('Utils', () => {

@ -1,16 +1,16 @@
/* eslint-disable no-await-in-loop */
import path from 'path';
import os from 'os';
import fs from 'fs-extra';
import path from 'path';
import AdmZip from 'adm-zip';
import fs from 'fs-extra';
import yaml from 'js-yaml';
import { Route, Handler } from 'hydrooj/src/service/server';
import type { ContentNode, ProblemConfigFile } from 'hydrooj';
import { ValidationError } from 'hydrooj/src/error';
import { buildContent } from 'hydrooj/src/lib/content';
import { ProblemAdd } from 'hydrooj/src/lib/ui';
import problem from 'hydrooj/src/model/problem';
import { PERM } from 'hydrooj/src/model/builtin';
import { buildContent } from 'hydrooj/src/lib/content';
import type { ContentNode, ProblemConfigFile } from 'hydrooj';
import problem from 'hydrooj/src/model/problem';
import { Handler, Route } from 'hydrooj/src/service/server';
fs.ensureDirSync('/tmp/hydro/import-qduoj');

@ -1,4 +1,5 @@
import 'hydrooj';
import * as superagent from 'superagent';
declare module 'hydrooj' {

@ -1,4 +1,5 @@
import 'hydrooj';
import * as superagent from 'superagent';
declare module 'hydrooj' {

@ -1,4 +1,5 @@
import 'hydrooj';
import * as superagent from 'superagent';
declare module 'hydrooj' {

@ -7,7 +7,7 @@
"license": "AGPL-3.0-or-later",
"preferUnplugged": true,
"dependencies": {
"ws": "^8.2.1"
"ws": "^8.2.2"
},
"devDependencies": {
"@types/ws": "^7.4.7"

@ -1,6 +1,6 @@
import WebSocket from 'ws';
import { } from 'hydrooj';
import * as bus from 'hydrooj/src/service/bus';
import WebSocket from 'ws';
declare module 'hydrooj' {
interface SystemKeys {

@ -2,9 +2,9 @@
/* eslint-disable no-await-in-loop */
import mysql from 'mysql';
import { buildContent } from 'hydrooj/src/lib/content';
import user from 'hydrooj/src/model/user';
import problem from 'hydrooj/src/model/problem';
import * as system from 'hydrooj/src/model/system';
import user from 'hydrooj/src/model/user';
export async function run({
host = 'localhost', port = 27017, name = 'vijos4', username, password,

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save