@eeplatform/basic-edu 1.10.1 → 1.10.2

package/dist/index.js

@@ -39329,6 +39329,7 @@ var schemaSection = import_joi31.default.object({
   _id: import_joi31.default.string().hex().optional().allow(null, ""),
   school: import_joi31.default.string().hex().required(),
   name: import_joi31.default.string().min(1).max(100).required(),
+  label: import_joi31.default.string().max(100).optional().allow(null, ""),
   schoolYear: import_joi31.default.string().required(),
   gradeLevel: import_joi31.default.string().required(),
   students: import_joi31.default.number().integer().min(0).optional(),
@@ -39345,8 +39346,7 @@ var schemaGenerateSections = import_joi31.default.object({
   gradeLevel: import_joi31.default.string().required(),
   minStudents: import_joi31.default.number().integer().min(1).required(),
   maxStudents: import_joi31.default.number().integer().min(import_joi31.default.ref("minStudents")).required(),
-  specialProgram: import_joi31.default.string().hex().optional().allow(null, ""),
-  set: import_joi31.default.array().items(import_joi31.default.string().min(1).max(100)).required()
+  specialProgram: import_joi31.default.string().hex().optional().allow(null, "")
 });
 function modelSection(value) {
   const { error } = schemaSection.validate(value);
@@ -39378,6 +39378,7 @@ function modelSection(value) {
     _id: value._id,
     school: value.school,
     name: value.name,
+    label: value.label ?? "",
     schoolYear: value.schoolYear,
     gradeLevel: value.gradeLevel,
     adviser: value.adviser,
@@ -39412,7 +39413,7 @@ function useSectionRepo() {
         { key: { createdAt: 1 } },
         { key: { name: "text", schoolYear: "text", gradeLevel: "text" } },
         {
-          key: { school: 1, name: 1, schoolYear: 1, status: 1 },
+          key: { school: 1, teacher: 1, schoolYear: 1, status: 1 },
           unique: true,
           name: "unique_section"
         }
@@ -39439,7 +39440,7 @@ function useSectionRepo() {
       value = modelSection(value);
       const res = await collection.insertOne(value, { session });
       delCachedData();
-      return res.insertedId;
+      return res.insertedId.toString();
     } catch (error) {
       import_nodejs_utils52.logger.log({
         level: "error",
@@ -39580,6 +39581,54 @@ function useSectionRepo() {
       }
     }
   }
+  async function getSection(options) {
+    const query = {};
+    const cacheKeyOptions = { tag: "getSection" };
+    try {
+      query.school = new import_mongodb30.ObjectId(options.school);
+      cacheKeyOptions.school = String(options.school);
+    } catch (error) {
+      throw new import_nodejs_utils52.BadRequestError("Invalid school ID.");
+    }
+    query.gradeLevel = options.gradeLevel;
+    cacheKeyOptions.gradeLevel = options.gradeLevel;
+    query.name = options.name;
+    cacheKeyOptions.name = options.name;
+    if (options.schoolYear) {
+      query.schoolYear = options.schoolYear;
+      cacheKeyOptions.schoolYear = options.schoolYear;
+    }
+    const cacheKey = (0, import_nodejs_utils52.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils52.logger.log({
+          level: "info",
+          message: `Cache hit for getSection: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne(query);
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils52.logger.log({
+          level: "info",
+          message: `Cache set for section: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils52.logger.log({
+          level: "error",
+          message: `Failed to set cache for section: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils52.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils52.InternalServerError("Failed to get section.");
+      }
+    }
+  }
   async function getByName(name) {
     const cacheKey = (0, import_nodejs_utils52.makeCacheKey)(namespace_collection, { name });
     try {
@@ -39763,6 +39812,7 @@ function useSectionRepo() {
     add,
     getAll,
     getById,
+    getSection,
     getByName,
     getBySchool,
     updateFieldById,
@@ -40007,11 +40057,73 @@ function useSectionStudentRepo() {
     });
     return data;
   }
+  async function getStudent(options) {
+    const query = {};
+    const cacheKeyOptions = { tag: "getStudent" };
+    if (options.learner) {
+      try {
+        query.learner = new import_mongodb32.ObjectId(options.learner);
+        cacheKeyOptions.learner = String(options.learner);
+      } catch (error) {
+        throw new import_nodejs_utils54.BadRequestError("Invalid learner ID.");
+      }
+    }
+    if (options.schoolYear) {
+      query.schoolYear = options.schoolYear;
+      cacheKeyOptions.schoolYear = options.schoolYear;
+    }
+    if (options.section) {
+      try {
+        query.section = new import_mongodb32.ObjectId(options.section);
+        cacheKeyOptions.section = String(options.section);
+      } catch (error) {
+        throw new import_nodejs_utils54.BadRequestError("Invalid section ID.");
+      }
+    }
+    if (options.gradeLevel) {
+      query.gradeLevel = options.gradeLevel;
+      cacheKeyOptions.gradeLevel = options.gradeLevel;
+    }
+    try {
+      query.student = new import_mongodb32.ObjectId(options.student);
+      cacheKeyOptions.student = String(options.student);
+    } catch (error) {
+      throw new import_nodejs_utils54.BadRequestError("Invalid student ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils54.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils54.logger.log({
+          level: "info",
+          message: `Cache hit for getStudent section student: ${cacheKey}`
+        });
+        return cached;
+      }
+      const item = await collection.findOne(query);
+      setCache(cacheKey, item, 600).then(() => {
+        import_nodejs_utils54.logger.log({
+          level: "info",
+          message: `Cache set for getStudent section student: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils54.logger.log({
+          level: "error",
+          message: `Failed to set cache for getStudent section student: ${err.message}`
+        });
+      });
+      return item;
+    } catch (error) {
+      import_nodejs_utils54.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
   return {
     createIndexes,
     delCachedData,
     add,
-    getAll
+    getAll,
+    getStudent
   };
 }
 
@@ -40348,6 +40460,63 @@ function useSectionSubjectRepo() {
       }
     }
   }
+  async function getSectionSubject(options) {
+    const query = {};
+    const cacheKeyOptions = { tag: "getSectionSubject" };
+    if (options.gradeLevel) {
+      query.gradeLevel = options.gradeLevel;
+      cacheKeyOptions.gradeLevel = options.gradeLevel;
+    }
+    if (options.schoolYear) {
+      query.schoolYear = options.schoolYear;
+      cacheKeyOptions.schoolYear = options.schoolYear;
+    }
+    if (options.subjectCode) {
+      query.subjectCode = options.subjectCode;
+      cacheKeyOptions.subjectCode = options.subjectCode;
+    }
+    try {
+      query.section = new import_mongodb34.ObjectId(options.section);
+      cacheKeyOptions.section = String(options.section);
+    } catch (error) {
+      throw new import_nodejs_utils56.BadRequestError("Invalid section ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils56.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache hit for getSectionSubject section subjects: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.find({
+        ...query,
+        deletedAt: { $in: ["", null] }
+      }).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache set for section subjects by getSectionSubject: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils56.logger.log({
+          level: "error",
+          message: `Failed to set cache for section subjects by getSectionSubject: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils56.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils56.InternalServerError(
+          "Failed to get section subjects by getSectionSubject."
+        );
+      }
+    }
+  }
   async function getBySection(section) {
     try {
       section = new import_mongodb34.ObjectId(section);
@@ -40580,6 +40749,7 @@ function useSectionSubjectRepo() {
     add,
     getAll,
     getById,
+    getSectionSubject,
     getBySection,
     getByTeacher,
     getBySchool,
@@ -40960,7 +41130,13 @@ function useTeachingLoadRepo() {
         { key: { status: 1 } },
         { key: { school: 1 } },
         { key: { teacher: 1 } },
-        { key: { schoolYear: 1 } }
+        { key: { gradeLevel: 1 } },
+        { key: { schoolYear: 1 } },
+        {
+          key: { school: 1, teacher: 1, schoolYear: 1, gradeLevel: 1 },
+          unique: true,
+          name: "unique_teaching_load_index"
+        }
       ]);
     } catch (error) {
       throw new Error("Failed to create index on teaching load.");
@@ -40980,7 +41156,11 @@ function useTeachingLoadRepo() {
       if (error instanceof import_nodejs_utils60.AppError) {
         throw error;
       } else {
-        throw new Error("Failed to create teaching load.");
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils60.BadRequestError("Teaching load already exist.");
+        }
+        throw new import_nodejs_utils60.InternalServerError("Failed to create teaching load.");
       }
     }
   }
@@ -41185,23 +41365,32 @@ function useTeachingLoadRepo() {
       }
     }
   }
-  async function getByTeacher(teacher, schoolYear) {
+  async function getByTeacher(options) {
+    const query = {};
+    const cacheKeyOptions = { tag: "getByTeacher" };
+    if (options.status) {
+      query.status = options.status;
+      cacheKeyOptions.status = options.status;
+    }
     try {
-      teacher = new import_mongodb36.ObjectId(teacher);
+      query.teacher = new import_mongodb36.ObjectId(options.teacher);
     } catch (error) {
       throw new import_nodejs_utils60.BadRequestError("Invalid teacher ID.");
     }
-    const query = {
-      teacher,
-      status: "active"
-    };
-    if (schoolYear) {
-      query.schoolYear = schoolYear;
+    cacheKeyOptions.teacher = String(options.teacher);
+    if (options.schoolYear) {
+      query.schoolYear = options.schoolYear;
+      cacheKeyOptions.schoolYear = options.schoolYear;
     }
-    const cacheKey = (0, import_nodejs_utils60.makeCacheKey)(namespace_collection, {
-      teacher: String(teacher),
-      schoolYear
-    });
+    if (options.school) {
+      try {
+        query.school = new import_mongodb36.ObjectId(options.school);
+      } catch (error) {
+        throw new import_nodejs_utils60.BadRequestError("Invalid school ID.");
+      }
+      cacheKeyOptions.school = String(options.school);
+    }
+    const cacheKey = (0, import_nodejs_utils60.makeCacheKey)(namespace_collection, cacheKeyOptions);
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
@@ -41455,7 +41644,7 @@ function useTeachingLoadController() {
       return;
     }
     try {
-      const result = await _getByTeacher(teacher, schoolYear);
+      const result = await _getByTeacher({ teacher, schoolYear });
       res.json(result);
       return;
     } catch (error2) {
@@ -42300,7 +42489,9 @@ function usePersonnelRepo() {
     page = 1,
     limit = 10,
     sort = {},
-    status = "active"
+    status = "active",
+    gradeLevel = "",
+    classification = ""
   } = {}) {
     page = page > 0 ? page - 1 : 0;
     const query = {
@@ -42324,6 +42515,14 @@ function usePersonnelRepo() {
       }
       cacheParams.school = school;
     }
+    if (gradeLevel) {
+      query.gradeLevels = gradeLevel;
+      cacheParams.gradeLevel = gradeLevel;
+    }
+    if (classification) {
+      query.classification = classification;
+      cacheParams.classification = classification;
+    }
     const cacheKey = (0, import_nodejs_utils67.makeCacheKey)(namespace_collection, cacheParams);
     import_nodejs_utils67.logger.log({
       level: "info",
@@ -42712,13 +42911,13 @@ function usePersonnelController() {
 function useSectionService() {
   const { getCountByGradeLevel, getByGradeLevel: getLeanerByGradeLevel } = useLearnerRepo();
   const { getByGradeLevel } = useGradeLevelRepo();
-  const { add: createSection } = useSectionRepo();
-  const { add: assignStudent } = useSectionStudentRepo();
+  const { add: createSection, getSection } = useSectionRepo();
+  const { add: assignStudent, getStudent } = useSectionStudentRepo();
   const { getAll: getAllCurriculumSubjects } = useSubjectRepo();
-  const { add: addSectionSubject } = useSectionSubjectRepo();
+  const { add: addSectionSubject, getSectionSubject } = useSectionSubjectRepo();
   const { getById: getSchoolById } = useSchoolRepo();
   const { getAll: getAllPersonnel } = usePersonnelRepo();
-  const { add: addTeachingLoad } = useTeachingLoadRepo();
+  const { add: addTeachingLoad, getByTeacher } = useTeachingLoadRepo();
   function distributeStudents(total, minPer, maxPer) {
     if (total <= 0)
       return [];
@@ -42789,12 +42988,6 @@ function useSectionService() {
       }
       const minPerSection = value.minStudents ?? gradeLevelData.minNumberOfLearners;
       const maxPerSection = value.maxStudents ?? gradeLevelData.maxNumberOfLearners;
-      const sectionsNeeded = Math.ceil(studentCount / minPerSection);
-      if (sectionsNeeded > value.set.length) {
-        throw new import_nodejs_utils69.BadRequestError(
-          "Insufficient number of section names in set[]."
-        );
-      }
       const sectionSizes = distributeStudents(
         studentCount,
         minPerSection,
@@ -42808,10 +43001,30 @@ function useSectionService() {
         throw new import_nodejs_utils69.BadRequestError("School not found.");
       }
       let totalStudentsProcessed = 0;
+      let sectionsGenerated = 0;
+      let sectionsSkipped = 0;
+      let teachingLoadsCreated = 0;
+      let teachingLoadsSkipped = 0;
+      let studentCreated = 0;
+      let studentSkipped = 0;
+      let subjectsAssigned = 0;
+      let subjectsSkipped = 0;
       for (let i = 0; i < sectionSizes.length; i++) {
         const size = sectionSizes[i];
-        const sectionName = value.set[i];
-        const section = await createSection(
+        const sectionName = String(i + 1);
+        const existingSection = await getSection({
+          gradeLevel: value.gradeLevel,
+          schoolYear: value.schoolYear,
+          name: sectionName,
+          school: value.school
+        });
+        let sectionId = "";
+        if (existingSection) {
+          sectionId = existingSection._id?.toString() || "";
+          sectionsSkipped++;
+          continue;
+        }
+        sectionId = await createSection(
           {
             school: value.school,
             schoolYear: value.schoolYear,
@@ -42821,6 +43034,10 @@ function useSectionService() {
           },
           session
         );
+        if (!sectionId) {
+          throw new import_nodejs_utils69.InternalServerError("Required section ID is missing.");
+        }
+        sectionsGenerated++;
         const skip = totalStudentsProcessed;
         const learners = await getLeanerByGradeLevel(
           {
@@ -42842,9 +43059,19 @@ function useSectionService() {
           if (!student.learnerInfo.lrn) {
             throw new import_nodejs_utils69.BadRequestError("Learner LRN is missing.");
           }
+          const existingStudent = await getStudent({
+            student: student._id.toString(),
+            schoolYear: value.schoolYear,
+            section: sectionId,
+            gradeLevel: value.gradeLevel
+          });
+          if (existingStudent) {
+            studentSkipped++;
+            continue;
+          }
           await assignStudent(
             {
-              section: section.toString(),
+              section: sectionId,
               lrn: student.learnerInfo.lrn,
               student: student._id?.toString(),
               studentName: `${student.learnerInfo.firstName} ${student.learnerInfo.lastName}`,
@@ -42857,37 +43084,50 @@ function useSectionService() {
             },
             session
           );
+          studentCreated++;
         }
-        const curriculumSubjects = await getAllCurriculumSubjects({
-          schoolYear: Number(value.schoolYear),
-          gradeLevel: value.gradeLevel,
-          limit: 20
-        });
-        for (const curriculumSubject of curriculumSubjects.items) {
-          await addSectionSubject(
-            {
-              curriculum: curriculumSubject.curriculum.toString(),
-              school: value.school,
-              schoolName: schoolData.name,
-              gradeLevel: value.gradeLevel,
-              educationLevel: gradeLevelData.educationLevel,
-              schoolYear: value.schoolYear,
-              section: section.toString(),
-              sectionName,
+        if (value.gradeLevel !== "kindergarten") {
+          const curriculumSubjects = await getAllCurriculumSubjects({
+            schoolYear: Number(value.schoolYear),
+            gradeLevel: value.gradeLevel,
+            limit: 20
+          });
+          for (const curriculumSubject of curriculumSubjects.items) {
+            const existingSectionSubject = await getSectionSubject({
+              section: sectionId,
               subjectCode: curriculumSubject.subjectCode,
-              subjectName: curriculumSubject.subjectName,
-              teacher: "",
-              teacherName: "",
-              schedule: "",
-              daysOfWeek: [],
-              classroom: "",
-              classroomName: "",
-              sessionDuration: curriculumSubject.sessionDuration,
-              sessionFrequency: curriculumSubject.sessionFrequency,
-              status: "draft"
-            },
-            session
-          );
+              schoolYear: value.schoolYear
+            });
+            if (existingSectionSubject) {
+              subjectsSkipped++;
+              continue;
+            }
+            await addSectionSubject(
+              {
+                curriculum: curriculumSubject.curriculum.toString(),
+                school: value.school,
+                schoolName: schoolData.name,
+                gradeLevel: value.gradeLevel,
+                educationLevel: gradeLevelData.educationLevel,
+                schoolYear: value.schoolYear,
+                section: sectionId,
+                sectionName,
+                subjectCode: curriculumSubject.subjectCode,
+                subjectName: curriculumSubject.subjectName,
+                teacher: "",
+                teacherName: "",
+                schedule: "",
+                daysOfWeek: [],
+                classroom: "",
+                classroomName: "",
+                sessionDuration: curriculumSubject.sessionDuration,
+                sessionFrequency: curriculumSubject.sessionFrequency,
+                status: "draft"
+              },
+              session
+            );
+            subjectsAssigned++;
+          }
         }
       }
       let pageTeacher = 1;
@@ -42896,7 +43136,9 @@ function useSectionService() {
       do {
         const teachersData = await getAllPersonnel({
           school: value.school,
-          limit: 100
+          limit: 100,
+          gradeLevel: value.gradeLevel,
+          classification: "teaching"
         });
         pagesTeachers = teachersData.pages;
         teachers.push(...teachersData.items);
@@ -42908,11 +43150,19 @@ function useSectionService() {
         );
       }
       if (teachers.length) {
-        for (let index = 0; index < teachers.length; index++) {
-          const teacher = teachers[index];
+        for (const teacher of teachers) {
           if (!teacher._id) {
             throw new import_nodejs_utils69.BadRequestError("Teacher ID is missing.");
           }
+          const existingLoad = await getByTeacher({
+            teacher: teacher._id.toString(),
+            school: value.school,
+            schoolYear: value.schoolYear
+          });
+          if (existingLoad) {
+            teachingLoadsSkipped++;
+            continue;
+          }
           await addTeachingLoad(
             {
               school: value.school,
@@ -42924,10 +43174,26 @@ function useSectionService() {
             },
             session
           );
+          teachingLoadsCreated++;
         }
       }
       await session.commitTransaction();
-      return "Sections generated successfully.";
+      return {
+        message: "Sections generated successfully.",
+        summary: {
+          sectionsGenerated,
+          sectionsSkipped,
+          totalSections: sectionsGenerated + sectionsSkipped,
+          studentsProcessed: totalStudentsProcessed,
+          studentCreated,
+          studentSkipped,
+          subjectsAssigned,
+          subjectsSkipped,
+          teachingLoadsCreated,
+          teachingLoadsSkipped,
+          totalStudents: studentCount
+        }
+      };
     } catch (error2) {
       await session.abortTransaction();
       if (error2 instanceof import_nodejs_utils69.AppError) {
@@ -42965,12 +43231,6 @@ function useSectionService() {
       }
       const minPerSection = value.minStudents ?? gradeLevelData.minNumberOfLearners;
       const maxPerSection = value.maxStudents ?? gradeLevelData.maxNumberOfLearners;
-      const sectionsNeeded = Math.ceil(studentCount / minPerSection);
-      if (sectionsNeeded > value.set.length) {
-        throw new import_nodejs_utils69.BadRequestError(
-          "Insufficient number of section names in set[]."
-        );
-      }
       const sectionSizes = distributeStudents(
         studentCount,
         minPerSection,
@@ -42980,7 +43240,7 @@ function useSectionService() {
         throw new import_nodejs_utils69.BadRequestError("Unable to compute section sizes.");
       }
       const sections = sectionSizes.map((size, index) => ({
-        name: value.set[index],
+        name: `${index + 1}`,
         value: size
       }));
       return {