将题目纳入rating计算系统

hydro/entry/common.ts

@@ -25,8 +25,8 @@ export const builtinHandler = [
 ];
 
 export const builtinScript = [
-    'install', 'rating', 'recalcRating', 'register', 'problemStat',
-    'blacklist', 'setSuperadmin', 'deleteUser',
+    'install', 'rating', 'register', 'problemStat', 'blacklist',
+    'setSuperadmin', 'deleteUser',
 ];
 
 function getFiles(folder: string, base = ''): string[] {

hydro/handler/home.ts

@@ -142,7 +142,8 @@ class HomeSecurityHandler extends Handler {
     @param('verifyPassword', Types.String)
     async postChangePassword(current: string, password: string, verifyPassword: string) {
         if (password !== verifyPassword) throw new VerifyPasswordError();
-        await user.changePassword(this.user._id, current, password);
+        this.user.checkPassword(current);
+        await user.setPassword(this.user._id, password);
         this.back();
     }
 

hydro/handler/record.ts

@@ -50,9 +50,9 @@ class RecordListHandler extends RecordHandler {
             rdocs,
             pdict,
             udict,
-            fliterPid: pid,
-            fliterTid: tid,
-            fliterUidOrName: uidOrName,
+            filterPid: pid,
+            filterTid: tid,
+            filterUidOrName: uidOrName,
         };
     }
 }

hydro/interface.ts

@@ -56,6 +56,7 @@ export type Udict = NumericDictionary<User>;
 export interface Pdoc {
     _id: ObjectID,
     domainId: string,
+    docType: number,
     docId: number,
     pid: string,
     owner: number,

hydro/model/document.ts

@@ -238,7 +238,7 @@ export async function setIfNotStatus(
         {
             domainId, docType, docId, uid, key: { $not: { $eq: ifNot } },
         },
-        { $set: { [key]: value, args } },
+        { $set: { [key]: value, ...args } },
         { upsert: true, returnOriginal: false },
     );
     return res.value;

hydro/model/problem.ts

@@ -10,6 +10,7 @@ import readConfig from '../lib/readConfig';
 export const pdocHidden: Pdoc = {
     _id: new ObjectID(),
     domainId: 'system',
+    docType: document.TYPE_PROBLEM,
     docId: -1,
     pid: '',
     owner: 1,

hydro/model/task.ts

@@ -57,6 +57,41 @@ export async function consume(query: any, cb: Function) {
     }, 100);
 }
 
+export class Consumer {
+    consuming: boolean;
+
+    running?: Promise<any>;
+
+    interval: NodeJS.Timeout;
+
+    filter: any;
+
+    func: Function;
+
+    constructor(filter: any, func: Function) {
+        this.consuming = true;
+        this.filter = filter;
+        this.func = func;
+        this.interval = setInterval(this.consume.bind(this), 100);
+    }
+
+    async consume() {
+        if (this.running || !this.consuming) return;
+        const res = await getFirst(this.filter);
+        if (res) {
+            this.running = this.func(res);
+            if (this.running instanceof Promise) await this.running;
+            this.running = null;
+        }
+    }
+
+    async destory() {
+        this.consuming = false;
+        clearInterval(this.interval);
+        if (this.running) await this.running;
+    }
+}
+
 global.Hydro.model.task = {
-    add, get, del, count, getFirst, consume,
+    Consumer, add, get, del, count, getFirst, consume,
 };

hydro/model/user.ts

@@ -156,17 +156,6 @@ export function setEmail(uid: number, mail: string) {
     return setById(uid, { mail, mailLower: mail.trim().toLowerCase() });
 }
 
-export async function changePassword(uid: number, currentPassword: string, newPassword: string) {
-    const udoc = await getById('system', uid);
-    if (!udoc) throw new UserNotFoundError(uid);
-    udoc.checkPassword(currentPassword);
-    const salt = String.random();
-    return await coll.findOneAndUpdate(
-        { _id: udoc._id },
-        { $set: { salt, hash: pwhash(newPassword, salt), hashType: 'hydro' } },
-    );
-}
-
 export async function inc(_id: number, field: string, n = 1) {
     const udoc = await coll.findOne({ _id });
     if (!udoc) throw new UserNotFoundError(_id);
@@ -234,7 +223,6 @@ export function ensureIndexes() {
 
 global.Hydro.model.user = {
     User,
-    changePassword,
     create,
     getByEmail,
     getById,

hydro/script/rating.ts

@@ -1,28 +1,150 @@
+/* eslint-disable no-await-in-loop */
+import { NumericDictionary } from 'lodash';
 import { ObjectID } from 'mongodb';
+import * as domain from '../model/domain';
 import * as contest from '../model/contest';
-import * as user from '../model/user';
+import * as problem from '../model/problem';
 import rating from '../lib/rating';
+import { STATUS } from '../model/builtin';
+import { Tdoc, Pdoc } from '../interface';
 
-export const description = 'Calculate the rating of a contest';
+export const description = 'Calculate rating of a domain, or all domains';
 
-export async function run({ domainId, contestId }) {
-    contestId = new ObjectID(contestId);
-    const tdoc = await contest.get(domainId, contestId);
-    const tsdocs = await contest.getMultiStatus(domainId, { docId: contestId })
-        .sort(contest.RULES[tdoc.rule].statusSort).toArray();
-    const udict = await user.getList(domainId, tsdocs.map((tsdoc) => tsdoc.uid));
-    const rankedTsdocs = contest.RULES[tdoc.rule].rank(tsdocs);
+type ND = NumericDictionary<number>
+
+function calc(udict: ND, rankedDocs: [number, number][]) {
     const users = [];
-    for (const result of rankedTsdocs) {
-        users.push({ ...result[1], rank: result[0], old: udict[result[1].uid].rating || 1500 });
+    for (const [rank, uid] of rankedDocs) {
+        users.push({ uid, rank, old: users[uid] || 1500 });
     }
     const rated = rating(users);
-    return rated;
+    for (const udoc of rated) {
+        udict[udoc.uid] = udoc.new;
+    }
+}
+
+async function runProblem(pdoc: Pdoc, udict: ND, report: Function): Promise<void>
+async function runProblem(
+    domainId: string, pid: number, udict: ND, report: Function
+): Promise<void>
+async function runProblem(...arg: Array<any>) {
+    const start = new Date().getTime();
+    const pdoc: Pdoc = (typeof arg[0] === 'string')
+        ? await contest.get(arg[0], arg[1], -1)
+        : arg[0];
+    const udict: ND = (typeof arg[0] === 'string') ? arg[2] : arg[1];
+    const report = (typeof arg[0] === 'string') ? arg[3] : arg[2];
+    // TODO maybe some other rules?
+    // TODO pagination
+    const psdocs = await problem.getMultiStatus(
+        pdoc.domainId, { docId: pdoc.docId, status: STATUS.STATUS_ACCEPTED },
+    ).sort('rid', 1).toArray();
+    const ranked = [];
+    for (const index of psdocs) {
+        ranked.push([index + 1, psdocs[index].uid]);
+    }
+    calc(udict, ranked);
+    await report({
+        case: {
+            status: STATUS.STATUS_ACCEPTED,
+            judgeText: `Problem ${pdoc.title} finished`,
+            time_ms: new Date().getTime() - start,
+            memory_kb: 0,
+            score: 0,
+        },
+    });
+}
+
+async function runContest(tdoc: Tdoc, udict: ND, report: Function): Promise<void>
+async function runContest(
+    domainId: string, tid: ObjectID, udict: ND, report: Function
+): Promise<void>
+async function runContest(...arg: Array<any>) {
+    const start = new Date().getTime();
+    const tdoc: Tdoc = (typeof arg[0] === 'string')
+        ? await contest.get(arg[0], arg[1], -1)
+        : arg[0];
+    const udict: ND = (typeof arg[0] === 'string') ? arg[2] : arg[1];
+    const report = (typeof arg[0] === 'string') ? arg[3] : arg[2];
+    const tsdocs = await contest.getMultiStatus(tdoc.domainId, tdoc.docId, tdoc.docType)
+        .sort(contest.RULES[tdoc.rule].statusSort).toArray();
+    const rankedTsdocs = contest.RULES[tdoc.rule].rank(tsdocs);
+    const ranked = [];
+    for (const result of rankedTsdocs) {
+        ranked.push([result[0], result[1].uid]);
+    }
+    calc(udict, ranked);
+    await report({
+        case: {
+            status: STATUS.STATUS_ACCEPTED,
+            judgeText: `Contest ${tdoc.title} finished`,
+            time_ms: new Date().getTime() - start,
+            memory_kb: 0,
+            score: 0,
+        },
+    });
+}
+
+async function runInDomain(domainId: string, isSub: boolean, report: Function) {
+    await domain.setMultiUserInDomain(domainId, {}, { rating: 1500 });
+    const udict: ND = {};
+    // TODO pagination
+    const problems = await problem.getMulti(domainId, { hidden: false }).toArray();
+    await report({ message: `Found ${problems.length} problems in ${domainId}` });
+    for (const i in problems) {
+        const pdoc = problems[i];
+        runProblem(pdoc, udict, report);
+        if (!isSub) {
+            await report({
+                progress: Math.floor(((parseInt(i, 10) + 1) / problems.length) * 100),
+            });
+        }
+    }
+    const contests = await contest.getMulti(domainId, { rated: true }, -1).sort('endAt', -1).toArray();
+    await report({ message: `Found ${contests.length} contests in ${domainId}` });
+    for (const i in contests) {
+        const tdoc = contests[i];
+        runContest(tdoc, udict, report);
+        if (!isSub) {
+            await report({
+                progress: Math.floor(((parseInt(i, 10) + 1) / contests.length) * 100),
+            });
+        }
+    }
+    const tasks = [];
+    for (const uid in udict) {
+        tasks.push(domain.setUserInDomain(domainId, parseInt(uid, 10), { rating: udict[uid] }));
+    }
+    await Promise.all(tasks);
+}
+
+export async function run({ domainId }, report: Function) {
+    if (!domainId) {
+        const domains = await domain.getMulti().toArray();
+        await report({ message: `Found ${domains.length} domains` });
+        for (const i in domains) {
+            const start = new Date().getTime();
+            await runInDomain(domains[i]._id, true, report);
+            await report({
+                case: {
+                    status: STATUS.STATUS_ACCEPTED,
+                    judgeText: `Domain ${domains[i]._id} finished`,
+                    time_ms: new Date().getTime() - start,
+                    memory_kb: 0,
+                    score: 0,
+                },
+                progress: Math.floor(((parseInt(i, 10) + 1) / domains.length) * 100),
+            });
+        }
+    } else runInDomain(domainId, false, report);
+    return true;
 }
 
 export const validate = {
-    domainId: { $type: 'string' },
-    contestId: { $type: ObjectID },
+    $or: [
+        { domainId: 'string' },
+        { domainId: 'undefined' },
+    ],
 };
 
-global.Hydro.script.rating = { run, description, validate };
+global.Hydro.script.recalcRating = { run, description, validate };

hydro/script/recalcRating.ts

@@ -1,75 +0,0 @@
-/* eslint-disable no-await-in-loop */
-import * as domain from '../model/domain';
-import * as contest from '../model/contest';
-import rating from '../lib/rating';
-import { STATUS } from '../model/builtin';
-
-export const description = 'Calculate rating of a domain, or all domains';
-
-export async function run({ domainId, isSub = false }, report: Function) {
-    if (!domainId) {
-        const domains = await domain.getMulti().toArray();
-        await report({ message: `Found ${domains.length} domains` });
-        for (const i in domains) {
-            const start = new Date().getTime();
-            await run({ domainId: domains[i]._id, isSub: true }, report);
-            await report({
-                case: {
-                    status: STATUS.STATUS_ACCEPTED,
-                    judgeText: `Domain ${domains[i]._id} finished`,
-                    time_ms: new Date().getTime() - start,
-                    memory_kb: 0,
-                    score: 0,
-                },
-                progress: Math.floor(((parseInt(i, 10) + 1) / domains.length) * 100),
-            });
-        }
-        return true;
-    }
-    await domain.setMultiUserInDomain(domainId, {}, { rating: 1500 });
-    const contests = await contest.getMulti(domainId, { rated: true }).sort('endAt', -1).toArray();
-    await report({ message: `Found ${contests.length} contests in ${domainId}` });
-    const udict = {};
-    for (const i in contests) {
-        const start = new Date().getTime();
-        const tdoc = contests[i];
-        const tsdocs = await contest.getMultiStatus(domainId, { docId: tdoc.docId })
-            .sort(contest.RULES[tdoc.rule].statusSort).toArray();
-        const rankedTsdocs = contest.RULES[tdoc.rule].rank(tsdocs);
-        const users = [];
-        for (const result of rankedTsdocs) {
-            users.push({ ...result[1], rank: result[0], old: udict[result[1].uid] || 1500 });
-        }
-        const rated = rating(users);
-        for (const udoc of rated) {
-            udict[udoc.uid] = udoc.new;
-        }
-        if (!isSub) {
-            await report({ progress: Math.floor(((parseInt(i, 10) + 1) / contests.length) * 100) });
-        }
-        await report({
-            case: {
-                status: STATUS.STATUS_ACCEPTED,
-                judgeText: `Contest ${tdoc.title} finished`,
-                time_ms: new Date().getTime() - start,
-                memory_kb: 0,
-                score: 0,
-            },
-        });
-    }
-    const tasks = [];
-    for (const uid in udict) {
-        tasks.push(domain.setUserInDomain(domainId, parseInt(uid, 10), { rating: udict[uid] }));
-    }
-    await Promise.all(tasks);
-    return true;
-}
-
-export const validate = {
-    $or: [
-        { domainId: 'string' },
-        { domainId: 'undefined' },
-    ],
-};
-
-global.Hydro.script.recalcRating = { run, description, validate };