训练（题单）功能

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
-*/