streamline enrolment process

src/Router.ts

@@ -70,7 +70,6 @@ router.use(
                 r.get("/info", CourseInformationController.getInformationByUUID);
                 r.get("/info/my", CourseInformationController.getUserCourseInformationByUUID);
                 r.get("/info/training", CourseInformationController.getCourseTrainingInformationByUUID);
-                r.get("/info/requirements", CourseInformationController.getCourseRequirements);
                 r.get("/info/requirements/validate", CourseInformationController.validateCourseRequirements);
             })
         );

src/controllers/course/CourseInformationController.ts

@@ -3,6 +3,7 @@ import { Course } from "../../models/Course";
 import { User } from "../../models/User";
 import { TrainingSession } from "../../models/TrainingSession";
 import { ActionRequirement } from "../../models/ActionRequirement";
+import RequirementHelper from "../../utility/helper/RequirementHelper";
 
 /**
  * Returns course information based on the provided uuid (request.query.uuid)
@@ -134,83 +135,45 @@ async function getCourseTrainingInformationByUUID(request: Request, response: Re
     response.send(data?.training_sessions ?? []);
 }
 
-/**
- * Returns the requested course's requirements as an array of strings
- * @param request
- * @param response
- */
-async function getCourseRequirements(request: Request, response: Response) {
-    const query = request.query as {course_uuid: string};
-    const requirements = await _getRequirementsFromCourse(query.course_uuid);
-    if (requirements == null) {
-        response.status(404).send();
-        return;
-    }
-
-    response.send(requirements);
-}
-
 async function validateCourseRequirements(request: Request, response: Response) {
-    const query = request.query as {course_uuid: string};
-    const requirements = await _getRequirementsFromCourse(query.course_uuid);
-    if (requirements == null) {
-        response.status(404).send();
-        return;
-    }
-
-    let req_ids_satisfied = new Map<number, boolean>;
-    for (const req of requirements) {
-        // do logic...
-
-        // if yes:
-        if (!req_ids_satisfied.has(req.req_id) || req_ids_satisfied.get(req.req_id)) {
-            req_ids_satisfied.set(req.req_id, true);
-        }
-
-        // if no:
-        //req_ids_satisfied.set(req.req_id, false);
-    }
-
-    let ids: number[] = [];
-    req_ids_satisfied.forEach((value, key) => {
-        if (value) {
-            ids.push(key);
-        }
-    });
-
-    response.send(ids);
-}
-
-async function _getRequirementsFromCourse(courseUUID: string) {
+    const user: User = request.body.user;
+    const query = request.query as { course_uuid: string };
     const course = await Course.findOne({
         where: {
-            uuid: courseUUID
+            uuid: query.course_uuid,
         },
-        include: [{
-            association: Course.associations.action_requirements
-        }]
+        include: [
+            {
+                association: Course.associations.action_requirements,
+            },
+        ],
     });
 
     if (course == null) {
         return null;
     }
 
     const actionRequirements = course.action_requirements?.filter((actionRequirement: ActionRequirement) => actionRequirement.type == "requirement");
-    let actions: { action: string, req_id: number }[] = [];
+    let requirements: { action: string; req_id: number; passed: boolean }[] = [];
 
-    actionRequirements?.forEach((actionRequirement: ActionRequirement) => {
-        actionRequirement.action.forEach((s) => {
-            actions.push({action: s, req_id: actionRequirement.id});
-        })
-    });
+    if (actionRequirements == null) {
+        response.send([]);
+        return;
+    }
 
-    return actions;
+    for (const actionRequirement of actionRequirements) {
+        for (const requirement of actionRequirement.action) {
+            const requirementPassed = await RequirementHelper.validateRequirement(user, requirement);
+            requirements.push({ action: requirement, req_id: actionRequirement.id, passed: requirementPassed });
+        }
+    }
+
+    response.send(requirements);
 }
 
 export default {
     getInformationByUUID,
     getUserCourseInformationByUUID,
     getCourseTrainingInformationByUUID,
-    getCourseRequirements,
-    validateCourseRequirements
+    validateCourseRequirements,
 };

src/controllers/user/UserCourseController.ts

@@ -76,14 +76,14 @@ async function getMyCourses(request: Request, response: Response) {
  * @param response
  */
 async function enrolInCourse(request: Request, response: Response) {
-    const reqUser: User = request.body.user;
-    const course_id = request.body.course_id;
+    const user: User = request.body.user;
+    const query = request.body as { course_uuid: string };
 
     const validation = ValidationHelper.validate([
         {
-            name: "course_id",
-            validationObject: course_id,
-            toValidate: [{ val: ValidationOptions.NON_NULL }, { val: ValidationOptions.NUMBER }],
+            name: "course_uuid",
+            validationObject: query.course_uuid,
+            toValidate: [{ val: ValidationOptions.NON_NULL }],
         },
     ]);
 
@@ -95,23 +95,23 @@ async function enrolInCourse(request: Request, response: Response) {
     // Get course in question
     const course: Course | null = await Course.findOne({
         where: {
-            id: course_id,
+            uuid: query.course_uuid,
         },
         include: [Course.associations.training_type, Course.associations.skill_template],
     });
 
     // If Course-Instance couldn't be found, throw an error (caught locally)
-    if (course == null) throw Error("Course with id " + course_id + " could not be found!");
+    if (course == null) throw Error("Course with id " + query.course_uuid + " could not be found!");
 
     // Enrol user in course
     const userBelongsToCourses = await UsersBelongsToCourses.findOrCreate({
         where: {
-            user_id: reqUser.id,
-            course_id: course_id,
+            user_id: user.id,
+            course_id: course.id,
         },
         defaults: {
-            user_id: reqUser.id,
-            course_id: course_id,
+            user_id: user.id,
+            course_id: course.id,
             completed: false,
             next_training_type: course?.training_type?.id ?? null,
             skill_set: course?.skill_template?.content ?? null,

src/utility/helper/RequirementHelper.ts

@@ -0,0 +1,9 @@
+import { User } from "../../models/User";
+
+async function validateRequirement(user: User, requirement: string): Promise<boolean> {
+    return true;
+}
+
+export default {
+    validateRequirement,
+};