ready to test

Testing Signed-off-by: Kenneth Obsequio <k80308392@gmail.com>
2026-09-27 00:12:54 +08:00 · 2026-06-22 10:06:58 +08:00
parent bf48c95467
commit 439bb33f77
189 changed files with 17559 additions and 686 deletions
@@ -10,15 +10,17 @@ const { syncJunction } = require("../../utils/courses/junction.util");
 const { archiveOne, archiveMany } = require("../../utils/courses/archive.util");
 const { restoreOne, restoreMany } = require("../../utils/courses/restore.util");
 const { getFieldValues } = require("../../utils/fieldValues.util");
+const logActivity = require('../../utils/logActivity.util');

 // ── Models ────────────────────────────────────────────────────────────────────

 const {
-  Course, CourseProduct, CourseRole, CourseProductCategory: CourseProductCat,
+  Course, CourseProductCategory: CourseProductCat,
  Unit, Lesson, LessonPage,
  CourseObjective, LessonObjective,
  CoursePrerequisite, CourseAssessment,
  UnitQuiz, QuizQuestion, QuizOption,
+  CourseInstructor,
 } = require("../../models/courses/courses.associations");

 const mdl_Users = require("../../models/users/users.mdl");
@@ -94,7 +96,7 @@ exports.createCourse = async (req, res) => {
      title, description, order_index,
      course_code, level, subscription,
      objectives = [],
-      product_ids = [], role_ids = [], category_ids = [],
+      category_ids = [],
      createdBy,
    } = req.body;

@@ -112,11 +114,10 @@ exports.createCourse = async (req, res) => {
    }, { transaction: t });

    await syncObjectivesCreate(CourseObjective, "course_id", course.course_id, objectives, t);
-    await syncJunction(CourseProduct, course.course_id, product_ids, "product_id", t);
-    await syncJunction(CourseRole, course.course_id, role_ids, "role_id", t);
    await syncJunction(CourseProductCat, course.course_id, category_ids, "category_id", t);

    await t.commit();
+    logActivity(req.user?.user_id, 'create_course', { entityType: 'course', entityId: course.course_id, details: { title: course.title } });
    return R.success(res, "Course created.", { data: course }, 201);
  } catch (err) {
    await t.rollback();
@@ -135,7 +136,7 @@ exports.updateCourse = async (req, res) => {
    const {
      title, description, order_index,
      course_code, level, subscription,
-      objectives, product_ids, role_ids, category_ids,
+      objectives, category_ids,
      updatedBy,
    } = req.body;

@@ -149,11 +150,10 @@ exports.updateCourse = async (req, res) => {
    await course.save({ transaction: t });

    if (objectives !== undefined) await syncObjectivesUpdate(CourseObjective, "course_id", courseId, objectives, t);
-    if (product_ids !== undefined) await syncJunction(CourseProduct, courseId, product_ids, "product_id", t);
-    if (role_ids !== undefined) await syncJunction(CourseRole, courseId, role_ids, "role_id", t);
    if (category_ids !== undefined) await syncJunction(CourseProductCat, courseId, category_ids, "category_id", t);

    await t.commit();
+    logActivity(req.user?.user_id, 'update_course', { entityType: 'course', entityId: Number(courseId), details: { title: course.title } });
    return R.success(res, "Course updated.", { data: course });
  } catch (err) {
    await t.rollback();
@@ -169,6 +169,7 @@ exports.archiveCourse = async (req, res) => {
    const record = await archiveOne(Course, { course_id: courseId, ...notDeleted }, req.user.user_id, t);
    if (!record) return R.error(res, "Course not found.", 404);
    await t.commit();
+    logActivity(req.user.user_id, 'archive_course', { entityType: 'course', entityId: Number(courseId) });
    return R.success(res, "Course archived.");
  } catch (err) {
    await t.rollback();
@@ -185,6 +186,7 @@ exports.bulkArchiveCourses = async (req, res) => {

    const count = await archiveMany(Course, "course_id", ids, req.user.user_id, t);
    await t.commit();
+    logActivity(req.user.user_id, 'bulk_archive_courses', { entityType: 'course', details: { ids, count } });
    return R.success(res, `${count} course${count !== 1 ? "s" : ""} archived.`);
  } catch (err) {
    await t.rollback();
@@ -231,6 +233,7 @@ exports.restoreCourse = async (req, res) => {
    const record = await restoreOne(Course, { course_id: courseId }, req.user.user_id, t);
    if (!record) return R.error(res, "Archived course not found.", 404);
    await t.commit();
+    logActivity(req.user.user_id, 'restore_course', { entityType: 'course', entityId: Number(courseId) });
    return R.success(res, "Course restored.", { data: record });
  } catch (err) {
    await t.rollback();
@@ -247,6 +250,7 @@ exports.bulkRestoreCourses = async (req, res) => {

    const count = await restoreMany(Course, "course_id", ids, req.user.user_id, t);
    await t.commit();
+    logActivity(req.user.user_id, 'bulk_restore_courses', { entityType: 'course', details: { ids, count } });
    return R.success(res, `${count} course${count !== 1 ? "s" : ""} restored.`);
  } catch (err) {
    await t.rollback();
@@ -304,6 +308,7 @@ exports.syncPrerequisites = async (req, res) => {
    }

    await t.commit();
+    logActivity(req.user?.user_id, 'sync_prerequisites', { entityType: 'course', entityId: Number(courseId), details: { count: prerequisites.length } });
    return R.success(res, "Prerequisites updated.");
  } catch (err) {
    await t.rollback();
@@ -380,6 +385,7 @@ exports.createUnit = async (req, res) => {
      createdBy: createdBy ?? null,
    });

+    logActivity(req.user?.user_id, 'create_unit', { entityType: 'unit', entityId: unit.unit_id, details: { title: unit.title } });
    return R.success(res, "Unit created.", { data: unit }, 201);
  } catch (err) {
    console.error("[UNIT][CREATE]", err);
@@ -402,6 +408,7 @@ exports.updateUnit = async (req, res) => {
    unit.updatedBy = updatedBy ?? null;

    await unit.save();
+    logActivity(req.user?.user_id, 'update_unit', { entityType: 'unit', entityId: Number(unitId) });
    return R.success(res, "Unit updated.", { data: unit });
  } catch (err) {
    console.error("[UNIT][UPDATE]", err);
@@ -416,6 +423,7 @@ exports.archiveUnit = async (req, res) => {
    const record = await archiveOne(Unit, { unit_id: unitId, course_id: courseId, ...notDeleted }, req.user.user_id, t);
    if (!record) return R.error(res, "Unit not found.", 404);
    await t.commit();
+    logActivity(req.user.user_id, 'archive_unit', { entityType: 'unit', entityId: Number(unitId) });
    return R.success(res, "Unit archived.");
  } catch (err) {
    await t.rollback();
@@ -436,6 +444,7 @@ exports.bulkArchiveUnits = async (req, res) => {

    const count = await archiveMany(Unit, "unit_id", validIds, req.user.user_id, t);
    await t.commit();
+    logActivity(req.user.user_id, 'bulk_archive_units', { entityType: 'unit', details: { ids: validIds, count } });
    return R.success(res, `${count} unit${count !== 1 ? "s" : ""} archived.`);
  } catch (err) {
    await t.rollback();
@@ -491,6 +500,7 @@ exports.restoreUnit = async (req, res) => {
    const record = await restoreOne(Unit, { unit_id: unitId, course_id: courseId, ...onlyDeleted }, req.user.user_id, t);
    if (!record) return R.error(res, "Archived unit not found.", 404);
    await t.commit();
+    logActivity(req.user.user_id, 'restore_unit', { entityType: 'unit', entityId: Number(unitId) });
    return R.success(res, "Unit restored.", { data: record });
  } catch (err) {
    await t.rollback();
@@ -511,6 +521,7 @@ exports.bulkRestoreUnits = async (req, res) => {

    const count = await restoreMany(Unit, "unit_id", validIds, req.user.user_id, t);
    await t.commit();
+    logActivity(req.user.user_id, 'bulk_restore_units', { entityType: 'unit', details: { ids: validIds, count } });
    return R.success(res, `${count} unit${count !== 1 ? "s" : ""} restored.`);
  } catch (err) {
    await t.rollback();
@@ -597,6 +608,7 @@ exports.createLesson = async (req, res) => {
    await syncObjectivesCreate(LessonObjective, "lesson_id", lesson.lesson_id, objectives, t);

    await t.commit();
+    logActivity(req.user?.user_id, 'create_lesson', { entityType: 'lesson', entityId: lesson.lesson_id, details: { title: lesson.title } });
    return R.success(res, "Lesson created.", { data: lesson }, 201);
  } catch (err) {
    await t.rollback();
@@ -635,6 +647,7 @@ exports.updateLesson = async (req, res) => {
      include: [{ model: LessonObjective, as: "objectives", order: [["order_index", "ASC"]] }],
    });

+    logActivity(req.user?.user_id, 'update_lesson', { entityType: 'lesson', entityId: Number(lessonId) });
    return R.success(res, "Lesson updated.", { data: updated });
  } catch (err) {
    await t.rollback();
@@ -655,6 +668,7 @@ exports.archiveLesson = async (req, res) => {

    if (!record) return R.error(res, "Lesson not found.", 404);
    await t.commit();
+    logActivity(req.user.user_id, 'archive_lesson', { entityType: 'lesson', entityId: Number(lessonId) });
    return R.success(res, "Lesson archived.");
  } catch (err) {
    await t.rollback();
@@ -678,6 +692,7 @@ exports.bulkArchiveLessons = async (req, res) => {

    const count = await archiveMany(Lesson, "lesson_id", validIds, req.user.user_id, t);
    await t.commit();
+    logActivity(req.user.user_id, 'bulk_archive_lessons', { entityType: 'lesson', details: { ids: validIds, count } });
    return R.success(res, `${count} lesson${count !== 1 ? "s" : ""} archived.`);
  } catch (err) {
    await t.rollback();
@@ -741,6 +756,7 @@ exports.restoreLesson = async (req, res) => {
    const record = await restoreOne(Lesson, { lesson_id: lessonId, unit_id: unitId, ...onlyDeleted }, req.user.user_id, t);
    if (!record) return R.error(res, "Archived lesson not found.", 404);
    await t.commit();
+    logActivity(req.user.user_id, 'restore_lesson', { entityType: 'lesson', entityId: Number(lessonId) });
    return R.success(res, "Lesson restored.", { data: record });
  } catch (err) {
    await t.rollback();
@@ -764,6 +780,7 @@ exports.bulkRestoreLessons = async (req, res) => {

    const count = await restoreMany(Lesson, "lesson_id", validIds, req.user.user_id, t);
    await t.commit();
+    logActivity(req.user.user_id, 'bulk_restore_lessons', { entityType: 'lesson', details: { ids: validIds, count } });
    return R.success(res, `${count} lesson${count !== 1 ? "s" : ""} restored.`);
  } catch (err) {
    await t.rollback();
@@ -811,6 +828,7 @@ exports.upsertLessonPage = async (req, res) => {
      console.error("[LESSON PAGE][DURATION]", durErr);
    }

+    logActivity(req.user?.user_id, 'upsert_lesson_page', { entityType: 'lesson', entityId: Number(lessonId) });
    return R.success(
      res,
      created ? "Lesson page created." : "Lesson page updated.",
@@ -871,6 +889,7 @@ exports.createQuiz = async (req, res) => {
      createdBy: createdBy ?? null,
    });

+    logActivity(req.user?.user_id, 'create_quiz', { entityType: 'quiz', entityId: quiz.quiz_id });
    return R.success(res, "Quiz created.", { data: quiz }, 201);
  } catch (err) {
    console.error("[QUIZ][CREATE]", err);
@@ -894,6 +913,7 @@ exports.updateQuiz = async (req, res) => {
    quiz.updatedBy = updatedBy ?? null;

    await quiz.save();
+    logActivity(req.user?.user_id, 'update_quiz', { entityType: 'quiz', entityId: Number(quizId) });
    return R.success(res, "Quiz updated.", { data: quiz });
  } catch (err) {
    console.error("[QUIZ][UPDATE]", err);
@@ -908,6 +928,7 @@ exports.deleteQuiz = async (req, res) => {
    const record = await archiveOne(UnitQuiz, { quiz_id: quizId, unit_id: unitId, ...notDeleted }, req.body.deletedBy, t);
    if (!record) return R.error(res, "Quiz not found.", 404);
    await t.commit();
+    logActivity(req.user?.user_id, 'archive_quiz', { entityType: 'quiz', entityId: Number(quizId) });
    return R.success(res, "Quiz archived.");
  } catch (err) {
    await t.rollback();
@@ -942,6 +963,7 @@ exports.restoreQuiz = async (req, res) => {
    const record = await restoreOne(UnitQuiz, { quiz_id: quizId, unit_id: unitId, ...onlyDeleted }, req.body.restoredBy, t);
    if (!record) return R.error(res, "Archived quiz not found.", 404);
    await t.commit();
+    logActivity(req.user?.user_id, 'restore_quiz', { entityType: 'quiz', entityId: Number(quizId) });
    return R.success(res, "Quiz restored.", { data: record });
  } catch (err) {
    await t.rollback();
@@ -1034,6 +1056,7 @@ exports.createQuestion = async (req, res) => {
      include: [{ model: QuizOption, as: "options", order: [["order_index", "ASC"]] }],
    });

+    logActivity(req.user?.user_id, 'create_question', { entityType: 'question', entityId: created.question_id });
    return R.success(res, "Question created.", { data: created }, 201);
  } catch (err) {
    await t.rollback();
@@ -1081,6 +1104,7 @@ exports.updateQuestion = async (req, res) => {
      include: [{ model: QuizOption, as: "options", order: [["order_index", "ASC"]] }],
    });

+    logActivity(req.user?.user_id, 'update_question', { entityType: 'question', entityId: Number(questionId) });
    return R.success(res, "Question updated.", { data: updated });
  } catch (err) {
    await t.rollback();
@@ -1096,6 +1120,7 @@ exports.deleteQuestion = async (req, res) => {
    const record = await archiveOne(QuizQuestion, { question_id: questionId, ...notDeleted }, req.body.deletedBy, t);
    if (!record) return R.error(res, "Question not found.", 404);
    await t.commit();
+    logActivity(req.user?.user_id, 'archive_question', { entityType: 'question', entityId: Number(questionId) });
    return R.success(res, "Question archived.");
  } catch (err) {
    await t.rollback();
@@ -1127,6 +1152,7 @@ exports.restoreQuestion = async (req, res) => {
    const record = await restoreOne(QuizQuestion, { question_id: questionId, ...onlyDeleted }, req.body.restoredBy, t);
    if (!record) return R.error(res, "Archived question not found.", 404);
    await t.commit();
+    logActivity(req.user?.user_id, 'restore_question', { entityType: 'question', entityId: Number(questionId) });
    return R.success(res, "Question restored.", { data: record });
  } catch (err) {
    await t.rollback();
@@ -1152,6 +1178,7 @@ exports.bulkArchiveQuestions = async (req, res) => {

    const count = await archiveMany(QuizQuestion, "question_id", validIds, deletedBy, t);
    await t.commit();
+    logActivity(req.user?.user_id, 'bulk_archive_questions', { entityType: 'question', details: { ids: validIds, count } });
    return R.success(res, `${count} question${count !== 1 ? "s" : ""} archived.`);
  } catch (err) {
    await t.rollback();
@@ -1177,6 +1204,7 @@ exports.bulkRestoreQuestions = async (req, res) => {

    const count = await restoreMany(QuizQuestion, "question_id", validIds, restoredBy, t);
    await t.commit();
+    logActivity(req.user?.user_id, 'bulk_restore_questions', { entityType: 'question', details: { ids: validIds, count } });
    return R.success(res, `${count} question${count !== 1 ? "s" : ""} restored.`);
  } catch (err) {
    await t.rollback();
@@ -1227,10 +1255,11 @@ exports.createAssessment = async (req, res) => {
      is_required: is_required ?? false,
      passing_score: passing_score ?? 70,
      time_limit_minutes: time_limit_minutes ?? null,
-      max_questions: max_questions ?? null,   // ← add
+      max_questions: max_questions ?? null,
      createdBy: createdBy ?? null,
    });

+    logActivity(req.user?.user_id, 'create_assessment', { entityType: 'assessment', entityId: assessment.assessment_id });
    return R.success(res, "Assessment created.", { data: assessment }, 201);
  } catch (err) {
    console.error("[ASSESSMENT][CREATE]", err);
@@ -1257,6 +1286,7 @@ exports.updateAssessment = async (req, res) => {
    assessment.updatedBy = updatedBy ?? null;

    await assessment.save();
+    logActivity(req.user?.user_id, 'update_assessment', { entityType: 'assessment', entityId: Number(assessmentId) });
    return R.success(res, "Assessment updated.", { data: assessment });
  } catch (err) {
    console.error("[ASSESSMENT][UPDATE]", err);
@@ -1271,6 +1301,7 @@ exports.deleteAssessment = async (req, res) => {
    const record = await archiveOne(CourseAssessment, { assessment_id: assessmentId, course_id: courseId, ...notDeleted }, req.body.deletedBy, t);
    if (!record) return R.error(res, "Assessment not found.", 404);
    await t.commit();
+    logActivity(req.user?.user_id, 'archive_assessment', { entityType: 'assessment', entityId: Number(assessmentId) });
    return R.success(res, "Assessment archived.");
  } catch (err) {
    await t.rollback();
@@ -1305,6 +1336,7 @@ exports.restoreAssessment = async (req, res) => {
    const record = await restoreOne(CourseAssessment, { assessment_id: assessmentId, course_id: courseId, ...onlyDeleted }, req.body.restoredBy, t);
    if (!record) return R.error(res, "Archived assessment not found.", 404);
    await t.commit();
+    logActivity(req.user?.user_id, 'restore_assessment', { entityType: 'assessment', entityId: Number(assessmentId) });
    return R.success(res, "Assessment restored.", { data: record });
  } catch (err) {
    await t.rollback();
@@ -1315,4 +1347,160 @@ exports.restoreAssessment = async (req, res) => {

 exports.getCourseFieldValues = getFieldValues(Course, "COURSE");
 exports.getUnitFieldValues   = getFieldValues(Unit,   "UNIT");
-exports.getLessonFieldValues = getFieldValues(Lesson, "LESSON");
+exports.getLessonFieldValues = getFieldValues(Lesson, "LESSON");
+
+// ── Flat lists for requirement builder dropdowns ───────────────────────────────
+// Returns lightweight id+title arrays (no pagination) used when building task requirements.
+
+exports.getCoursesFlat = async (req, res) => {
+  try {
+    const data = await Course.findAll({
+      where: notDeleted,
+      attributes: ["uuid", "title"],
+      order: [["title", "ASC"]],
+    });
+    return R.success(res, "Courses retrieved.", data);
+  } catch (err) {
+    console.error("[COURSE][GET FLAT]", err);
+    return R.error(res, "Could not retrieve courses.", 500);
+  }
+};
+
+exports.getUnitsFlat = async (req, res) => {
+  try {
+    const rows = await Unit.findAll({
+      where: notDeleted,
+      attributes: ["uuid", "title", "order_index"],
+      include: [{
+        model: Course,
+        as: "course",
+        attributes: ["title"],
+      }],
+      order: [
+        [{ model: Course, as: "course" }, "title", "ASC"],
+        ["order_index", "ASC"],
+      ],
+    });
+    const data = rows.map((u) => ({
+      uuid:         u.uuid,
+      title:        u.title,
+      order_index:  u.order_index ?? 0,
+      course_title: u.course?.title ?? "",
+    }));
+    return R.success(res, "Units retrieved.", data);
+  } catch (err) {
+    console.error("[UNIT][GET FLAT]", err);
+    return R.error(res, "Could not retrieve units.", 500);
+  }
+};
+
+exports.getLessonsFlat = async (req, res) => {
+  try {
+    const rows = await Lesson.findAll({
+      where: notDeleted,
+      attributes: ["uuid", "title", "order_index"],
+      include: [{
+        model: Unit,
+        as: "unit",
+        attributes: ["title", "order_index"],
+        include: [{
+          model: Course,
+          as: "course",
+          attributes: ["title"],
+        }],
+      }],
+      order: [
+        [{ model: Unit, as: "unit" }, { model: Course, as: "course" }, "title", "ASC"],
+        [{ model: Unit, as: "unit" }, "order_index", "ASC"],
+        ["order_index", "ASC"],
+      ],
+    });
+    const data = rows.map((l) => ({
+      uuid:        l.uuid,
+      title:       l.title,
+      order_index: l.order_index ?? 0,
+      unit_title:  l.unit?.title ?? "",
+      unit_order:  l.unit?.order_index ?? 0,
+      course_title: l.unit?.course?.title ?? "",
+    }));
+    return R.success(res, "Lessons retrieved.", data);
+  } catch (err) {
+    console.error("[LESSON][GET FLAT]", err);
+    return R.error(res, "Could not retrieve lessons.", 500);
+  }
+};
+// ══════════════════════════════════════════════════════════════════════════════
+// COURSE INSTRUCTORS
+// ══════════════════════════════════════════════════════════════════════════════
+
+exports.getInstructors = async (req, res) => {
+  try {
+    const { courseId } = req.params;
+
+    const instructors = await CourseInstructor.findAll({
+      where: { course_id: courseId },
+      order: [["order_index", "ASC"]],
+      include: [{
+        model:      mdl_Users,
+        as:         "user",
+        attributes: ["user_id", "email", "acc_type", "personal_info"],
+        required:   false,
+      }],
+    });
+
+    return R.success(res, "Instructors retrieved.", { data: instructors });
+  } catch (err) {
+    console.error("[INSTRUCTOR][GET]", err);
+    return R.error(res, "Could not retrieve instructors.", 500);
+  }
+};
+
+exports.syncInstructors = async (req, res) => {
+  const t = await sequelize.transaction();
+  try {
+    const { courseId }        = req.params;
+    const { instructors = [] } = req.body;
+    const actor_id             = req.user?.user_id ?? null;
+
+    const course = await Course.findOne({ where: { course_id: courseId, ...notDeleted } });
+    if (!course) return R.error(res, "Course not found.", 404);
+
+    // Validate any linked user_ids are staff or admin
+    const linkedIds = instructors.map(i => i.user_id).filter(Boolean);
+    if (linkedIds.length) {
+      const validUsers = await mdl_Users.findAll({
+        where: { user_id: linkedIds, acc_type: ["staff", "admin"], deletedAt: null },
+        attributes: ["user_id"],
+      });
+      const validSet = new Set(validUsers.map(u => String(u.user_id)));
+      const invalid  = linkedIds.find(id => !validSet.has(String(id)));
+      if (invalid) {
+        await t.rollback();
+        return R.error(res, `User ${invalid} is not a staff or admin account.`, 422);
+      }
+    }
+
+    await CourseInstructor.destroy({ where: { course_id: courseId }, transaction: t });
+
+    if (instructors.length) {
+      await CourseInstructor.bulkCreate(
+        instructors.map((inst, i) => ({
+          course_id:    courseId,
+          user_id:      inst.user_id      ?? null,
+          display_name: inst.display_name,
+          order_index:  inst.order_index  ?? i,
+          created_by:   actor_id,
+        })),
+        { transaction: t }
+      );
+    }
+
+    await t.commit();
+    logActivity(actor_id, 'sync_instructors', { entityType: 'course', entityId: Number(courseId), details: { count: instructors.length } });
+    return R.success(res, "Instructors updated.");
+  } catch (err) {
+    await t.rollback();
+    console.error("[INSTRUCTOR][SYNC]", err);
+    return R.error(res, "Could not update instructors.", 500);
+  }
+};