训练（题单）功能

hydro/model/contest.js

@@ -211,7 +211,7 @@ async def recalc_status(domainId: str, doc_type: int, cid: objeccid.Objeccid):
   tdoc = await document.get(domainId, doc_type, cid)
   async with document.get_multi_status(domainId=domainId,
                                        doc_type=doc_type,
-                                       doc_id=tdoc['doc_id']) as tsdocs:
+                                       doc_id=tdoc._id) as tsdocs:
     async for tsdoc in tsdocs:
       if 'journal' not in tsdoc or not tsdoc['journal']:
         continue

hydro/model/problem.js

@@ -56,7 +56,7 @@ async function add({
 async function get(pid, uid = null) {
     let query = {};
     if (pid.generationTime || pid.length === 24) query = { _id: new ObjectID(pid) };
-    else query = { pid: parseInt(pid) || pid };
+    else query = { pid };
     const pdoc = await coll.findOne(query);
     if (!pdoc) throw new ProblemNotFoundError(pid);
     if (uid) {
@@ -91,6 +91,13 @@ function getMany(query, sort, page, limit) {
 function getMulti(query) {
     return coll.find(query);
 }
+/**
+ * @param {object} query
+ * @returns {Cursor}
+ */
+function getMultiStatus(query) {
+    return collStatus.find(query);
+}
 /**
  * @param {ObjectID} _id
  * @param {object} query
@@ -120,6 +127,12 @@ async function getList(pids) {
     for (const pid of pids) r[pid] = await get(pid); // eslint-disable-line no-await-in-loop
     return r;
 }
+async function getListStatus(uid, pids) {
+    const psdocs = await getMultiStatus({ uid, pid: { $in: Array.from(new Set(pids)) } }).toArray();
+    const r = {};
+    for (const psdoc of psdocs) r[psdoc.pid] = psdoc;
+    return r;
+}
 
 module.exports = {
     add,
@@ -131,4 +144,6 @@ module.exports = {
     getById,
     getMulti,
     getList,
+    getListStatus,
+    getMultiStatus,
 };

hydro/model/training.js

@@ -1,67 +1,100 @@
+const assert = require('assert');
 const validator = require('../lib/validator');
-const { ValidationError, TrainingNotFoundError } = require('../error');
+const { ValidationError, TrainingNotFoundError, TrainingAlreadyEnrollError } = require('../error');
 const db = require('../service/db.js');
 
 const coll = db.collection('traning');
 const collStatus = db.collection('training.status');
 
-module.exports = {
-    SETTING_DIFFICULTY_ALGORITHM: 0,
-    SETTING_DIFFICULTY_ADMIN: 1,
-    SETTING_DIFFICULTY_AVERAGE: 2,
+async function enroll(tid, uid) {
+    try {
+        await collStatus.insertOne({ tid, uid, enroll: 1 });
+    } catch (e) {
+        throw new TrainingAlreadyEnrollError(tid, uid);
+    }
+    await coll.findOneAndUpdate({ _id: tid }, { $inc: { enroll: 1 } });
+}
+async function setStatus(tid, uid, $set) {
+    await collStatus.findOneAndUpdate({ tid, uid }, { $set });
+    return await collStatus.findOne({ tid, uid });
+}
 
-    async add(title, content, owner, dag = [], desc = '') {
+module.exports = {
+    getPids(tdoc) {
+        console.log(tdoc.dag);
+        const pids = new Set();
+        for (const node of tdoc.dag) {
+            for (const pid of node.pids) pids.add(pid);
+        }
+        return Array.from(pids);
+    },
+    isDone(node, doneNids, donePids) {
+        return (Set.isSuperset(new Set(doneNids), new Set(node.requireNids))
+            && Set.isSuperset(new Set(donePids), new Set(node.pids)));
+    },
+    isProgress(node, doneNids, donePids, progPids) {
+        return (Set.isSuperset(new Set(doneNids), new Set(node.requireNids))
+            && !Set.isSuperset(new Set(donePids), new Set(node.pids))
+            && Set.intersection(
+                Set.union(new Set(donePids), new Set(progPids)),
+                new Set(node.pids),
+            ).size);
+    },
+    isOpen(node, doneNids, donePids, progPids) {
+        return (Set.isSuperset(new Set(doneNids), new Set(node.requireNids))
+            && !Set.isSuperset(new Set(donePids), new Set(node.pids))
+            && !Set.intersection(
+                Set.union(new Set(donePids), new Set(progPids)),
+                new Set(node.pids),
+            ).size);
+    },
+    isInvalid(node, doneNids) {
+        return (!Set.isSuperset(new Set(doneNids), new Set(node.requireNids)));
+    },
+    async add(title, content, owner, dag = [], description = '') {
         validator.checkTitle(title);
         validator.checkIntro(content);
-        validator.checkDescription(desc);
-        for (const node of dag) { for (const nid of node.require_nids) if (nid >= node._id) throw new ValidationError('dag'); }
-        return await coll.insertOne({
+        validator.checkDescription(description);
+        for (const node of dag) {
+            for (const nid of node.requireNids) {
+                if (nid >= node._id) throw new ValidationError('dag');
+            }
+        }
+        const res = await coll.insertOne({
             content,
             owner,
             dag,
             title,
-            desc,
+            description,
             enroll: 0,
         });
+        return res.insertedId;
     },
     count: (query) => coll.find(query).count(),
     async edit(tid, $set) {
-        if ($set.title) validator.check_title($set.title);
-        if ($set.content) validator.check_intro($set.content);
-        if ($set.desc) validator.check_description($set.desc);
-        if ($set.dag) { for (const node of $set.dag) for (const nid of node.require_nids) if (nid >= node._id) throw new ValidationError('dag'); }
-        await coll.findOneAndUpdate({ tid }, { $set });
-        const tdoc = await coll.findOne({ tid });
+        if ($set.title) validator.checkTitle($set.title);
+        if ($set.content) validator.checkIntro($set.content);
+        if ($set.desc) validator.checkDescription($set.description);
+        if ($set.dag) {
+            for (const node of $set.dag) {
+                for (const nid of node.requireNids) {
+                    assert(nid >= node._id, new ValidationError('dag'));
+                }
+            }
+        }
+        await coll.findOneAndUpdate({ _id: tid }, { $set });
+        const tdoc = await coll.findOne({ _id: tid });
         if (!tdoc) throw new TrainingNotFoundError(tid);
         return tdoc;
     },
     async get(tid) {
-        const tdoc = await coll.findOne({ tid });
+        const tdoc = await coll.findOne({ _id: tid });
         if (!tdoc) throw new TrainingNotFoundError(tid);
         return tdoc;
     },
-    get_multi: (query) => coll.find(query),
-    get_multi_status: (query) => collStatus.find(query),
-    get_status: (tid, uid) => collStatus.findOne({ tid, uid }),
-    set_status: (tid, uid, $set) => collStatus.findOneAndUpdate({ tid, uid }, { $set }),
-
+    getMulti: (query) => coll.find(query),
+    getMultiStatus: (query) => collStatus.find(query),
+    getStatus: (tid, uid) => collStatus.findOne({ tid, uid }),
+    enroll,
+    setStatus,
 };
-
-/*
-async def get_dict_status(domainId, uid, tids, *, fields=None):
-  result = dict()
-  async for tsdoc in get_multi_status(domainId=domainId,
-                                      uid=uid,
-                                      doc_id={'$in': list(set(tids))},
-                                      fields=fields):
-    result[tsdoc['doc_id']] = tsdoc
-  return result
-
-async def get_dict(domainId, tids, *, fields=None):
-  result = dict()
-  async for tdoc in get_multi(domainId=domainId,
-                              doc_id={'$in': list(set(tids))},
-                              fields=fields):
-    result[tdoc['doc_id']] = tdoc
-  return result
-*/