@eeplatform/basic-edu 1.5.2 → 1.6.0

package/dist/index.js

@@ -1344,10 +1344,13 @@ var require_papaparse = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   MAsset: () => MAsset,
+  MBuilding: () => MBuilding,
+  MBuildingUnit: () => MBuildingUnit,
   MCurriculum: () => MCurriculum,
   MCurriculumSubject: () => MCurriculumSubject,
   MGradeLevel: () => MGradeLevel,
   MLearner: () => MLearner,
+  MPersonnel: () => MPersonnel,
   MPlantilla: () => MPlantilla,
   MStockCard: () => MStockCard,
   allowedSectionStudentStatuses: () => allowedSectionStudentStatuses,
@@ -1358,9 +1361,12 @@ __export(src_exports, {
   modelSection: () => modelSection,
   modelSectionPreset: () => modelSectionPreset,
   modelSectionStudent: () => modelSectionStudent,
+  modelSectionSubject: () => modelSectionSubject,
   schemaAsset: () => schemaAsset,
   schemaAssetUpdateOption: () => schemaAssetUpdateOption,
   schemaBasicEduCount: () => schemaBasicEduCount,
+  schemaBuilding: () => schemaBuilding,
+  schemaBuildingUnit: () => schemaBuildingUnit,
   schemaCurriculum: () => schemaCurriculum,
   schemaCurriculumSubject: () => schemaCurriculumSubject,
   schemaCurriculumSubjectAdd: () => schemaCurriculumSubjectAdd,
@@ -1369,6 +1375,7 @@ __export(src_exports, {
   schemaEnrollment: () => schemaEnrollment,
   schemaGenerateSections: () => schemaGenerateSections,
   schemaGradeLevel: () => schemaGradeLevel,
+  schemaPersonnel: () => schemaPersonnel,
   schemaPlantilla: () => schemaPlantilla,
   schemaRegion: () => schemaRegion,
   schemaSchool: () => schemaSchool,
@@ -1376,11 +1383,20 @@ __export(src_exports, {
   schemaSection: () => schemaSection,
   schemaSectionPreset: () => schemaSectionPreset,
   schemaSectionStudent: () => schemaSectionStudent,
+  schemaSectionSubject: () => schemaSectionSubject,
+  schemaSectionSubjectSetup: () => schemaSectionSubjectSetup,
   schemaStockCard: () => schemaStockCard,
+  schemaUpdateOptions: () => schemaUpdateOptions,
   schemaUpdateStatus: () => schemaUpdateStatus,
   useAssetController: () => useAssetController,
   useAssetRepo: () => useAssetRepo,
   useBasicEduCountRepo: () => useBasicEduCountRepo,
+  useBuildingController: () => useBuildingController,
+  useBuildingRepo: () => useBuildingRepo,
+  useBuildingService: () => useBuildingService,
+  useBuildingUnitController: () => useBuildingUnitController,
+  useBuildingUnitRepo: () => useBuildingUnitRepo,
+  useBuildingUnitService: () => useBuildingUnitService,
   useCurriculumController: () => useCurriculumController,
   useCurriculumRepo: () => useCurriculumRepo,
   useCurriculumSubjectController: () => useCurriculumSubjectController,
@@ -1396,6 +1412,8 @@ __export(src_exports, {
   useGradeLevelRepo: () => useGradeLevelRepo,
   useLearnerController: () => useLearnerController,
   useLearnerRepo: () => useLearnerRepo,
+  usePersonnelController: () => usePersonnelController,
+  usePersonnelRepo: () => usePersonnelRepo,
   usePlantillaController: () => usePlantillaController,
   usePlantillaRepo: () => usePlantillaRepo,
   usePlantillaService: () => usePlantillaService,
@@ -1409,6 +1427,9 @@ __export(src_exports, {
   useSectionPresetRepo: () => useSectionPresetRepo,
   useSectionRepo: () => useSectionRepo,
   useSectionStudentRepo: () => useSectionStudentRepo,
+  useSectionSubjectController: () => useSectionSubjectController,
+  useSectionSubjectRepo: () => useSectionSubjectRepo,
+  useSectionSubjectService: () => useSectionSubjectService,
   useStockCardController: () => useStockCardController,
   useStockCardRepository: () => useStockCardRepository,
   useStockCardService: () => useStockCardService
@@ -3587,8 +3608,11 @@ function useLearnerRepo() {
     }
   }
   async function getByGradeLevel(value, session) {
+    value.limit = value.limit && value.limit > 0 ? value.limit : 50;
+    value.skip = value.skip && value.skip > 0 ? value.skip - 1 : 0;
     const validation = import_joi7.default.object({
       school: import_joi7.default.string().hex().required(),
+      schoolYear: import_joi7.default.string().optional(),
       gradeLevel: import_joi7.default.string().required(),
       status: import_joi7.default.string().optional().allow("", null),
       limit: import_joi7.default.number().integer().required(),
@@ -3605,8 +3629,14 @@ function useLearnerRepo() {
     };
     const cacheKeyOptions = {
       ...query,
-      tag: "byGradeLevel"
+      tag: "byGradeLevel",
+      limit: value.limit,
+      skip: value.skip
     };
+    if (value.schoolYear) {
+      query.schoolYear = value.schoolYear;
+      cacheKeyOptions.schoolYear = value.schoolYear;
+    }
     if (value.school && typeof value.school === "string") {
       try {
         query.school = new import_mongodb7.ObjectId(value.school);
@@ -3626,11 +3656,7 @@ function useLearnerRepo() {
     }
     try {
       const data = await collection.aggregate(
-        [
-          { $match: query },
-          { $skip: value.skip ?? 0 },
-          { $limit: value.limit ?? 100 }
-        ],
+        [{ $match: query }, { $skip: value.skip }, { $limit: value.limit }],
         { session }
       ).toArray();
       setCache(cacheKey, data, 600).then(() => {
@@ -37820,11 +37846,11 @@ function useSectionRepo() {
 }
 
 // src/resources/section/section.controller.ts
-var import_nodejs_utils49 = require("@eeplatform/nodejs-utils");
-var import_joi29 = __toESM(require("joi"));
+var import_nodejs_utils53 = require("@eeplatform/nodejs-utils");
+var import_joi31 = __toESM(require("joi"));
 
 // src/resources/section/section.service.ts
-var import_nodejs_utils48 = require("@eeplatform/nodejs-utils");
+var import_nodejs_utils52 = require("@eeplatform/nodejs-utils");
 
 // src/resources/section-student/section.student.repository.ts
 var import_nodejs_utils47 = require("@eeplatform/nodejs-utils");
@@ -37949,196 +37975,614 @@ function useSectionStudentRepo() {
   };
 }
 
-// src/resources/section/section.service.ts
-function useSectionService() {
-  const { getCountByGradeLevel, getByGradeLevel: getLeanerByGradeLevel } = useLearnerRepo();
-  const { getByGradeLevel } = useGradeLevelRepo();
-  const { add: createSection } = useSectionRepo();
-  const { add: assignStudent } = useSectionStudentRepo();
-  function distributeStudents(total, minPer, maxPer) {
-    if (total <= 0)
-      return [];
-    if (minPer <= 0 || maxPer <= 0)
-      return [];
-    if (minPer > maxPer) {
-      throw new import_nodejs_utils48.BadRequestError(
-        "Minimum students per section cannot be greater than maximum."
-      );
+// src/resources/section-subject/section.subject.model.ts
+var import_nodejs_utils48 = require("@eeplatform/nodejs-utils");
+var import_joi29 = __toESM(require("joi"));
+var import_mongodb28 = require("mongodb");
+var schemaSectionSubject = import_joi29.default.object({
+  _id: import_joi29.default.string().hex().optional().allow(null, ""),
+  school: import_joi29.default.string().hex().required(),
+  schoolName: import_joi29.default.string().optional().allow(null, ""),
+  section: import_joi29.default.string().hex().required(),
+  sectionName: import_joi29.default.string().required(),
+  gradeLevel: import_joi29.default.string().required(),
+  educationLevel: import_joi29.default.string().required(),
+  schoolYear: import_joi29.default.string().required(),
+  subjectCode: import_joi29.default.string().required(),
+  subjectName: import_joi29.default.string().required(),
+  teacher: import_joi29.default.string().hex().optional().allow(null, ""),
+  teacherName: import_joi29.default.string().optional().allow(null, ""),
+  classroom: import_joi29.default.string().optional().allow(null, ""),
+  classroomName: import_joi29.default.string().optional().allow(null, ""),
+  daysOfWeek: import_joi29.default.array().items(import_joi29.default.string()).optional().allow(null),
+  schedule: import_joi29.default.string().optional().allow(null, ""),
+  sessionDuration: import_joi29.default.number().optional().allow(null, 0),
+  sessionFrequency: import_joi29.default.number().optional().allow(null, 0),
+  status: import_joi29.default.string().valid("active", "draft").optional(),
+  createdAt: import_joi29.default.string().isoDate().optional().allow(null, ""),
+  updatedAt: import_joi29.default.string().isoDate().optional().allow(null, ""),
+  deletedAt: import_joi29.default.string().isoDate().optional().allow(null, "")
+});
+var schemaSectionSubjectSetup = import_joi29.default.object({
+  teacher: import_joi29.default.string().hex().optional().allow(null, ""),
+  teacherName: import_joi29.default.string().optional().allow(null, ""),
+  classroom: import_joi29.default.string().optional().allow(null, ""),
+  classroomName: import_joi29.default.string().optional().allow(null, ""),
+  daysOfWeek: import_joi29.default.array().items(import_joi29.default.string()).optional().allow(null),
+  schedule: import_joi29.default.string().optional().allow(null, "")
+});
+function modelSectionSubject(value) {
+  const { error } = schemaSectionSubject.validate(value);
+  if (error) {
+    throw new import_nodejs_utils48.BadRequestError(`Invalid section subject data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb28.ObjectId(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
     }
-    const minSections = Math.ceil(total / maxPer);
-    const maxSections = Math.floor(total / minPer);
-    let sectionCount;
-    if (minSections <= maxSections) {
-      sectionCount = minSections;
-    } else {
-      sectionCount = minSections;
+  }
+  if (value.school && typeof value.school === "string") {
+    try {
+      value.school = new import_mongodb28.ObjectId(value.school);
+    } catch (error2) {
+      throw new Error("Invalid school ID.");
     }
-    const base = Math.floor(total / sectionCount);
-    const extra = total % sectionCount;
-    const sizes = new Array(sectionCount).fill(base);
-    for (let i = 0; i < extra; i++) {
-      sizes[i] += 1;
+  }
+  if (value.section && typeof value.section === "string") {
+    try {
+      value.section = new import_mongodb28.ObjectId(value.section);
+    } catch (error2) {
+      throw new Error("Invalid section ID.");
     }
-    for (const size of sizes) {
-      if (size > maxPer) {
-        throw new import_nodejs_utils48.BadRequestError(
-          `Generated section exceeds max limit of ${maxPer}.`
-        );
+  }
+  if (value.teacher && typeof value.teacher === "string") {
+    try {
+      value.teacher = new import_mongodb28.ObjectId(value.teacher);
+    } catch (error2) {
+      throw new Error("Invalid teacher ID.");
+    }
+  }
+  return {
+    _id: value._id,
+    school: value.school,
+    schoolName: value.schoolName,
+    section: value.section,
+    sectionName: value.sectionName,
+    gradeLevel: value.gradeLevel,
+    educationLevel: value.educationLevel,
+    schoolYear: value.schoolYear,
+    subjectCode: value.subjectCode,
+    subjectName: value.subjectName,
+    teacher: value.teacher,
+    teacherName: value.teacherName,
+    classroom: value.classroom ?? "",
+    classroomName: value.classroomName ?? "",
+    daysOfWeek: value.daysOfWeek ?? [],
+    schedule: value.schedule ?? "",
+    sessionDuration: value.sessionDuration ?? 0,
+    sessionFrequency: value.sessionFrequency ?? 0,
+    status: value.status ?? "draft",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/resources/section-subject/section.subject.repository.ts
+var import_nodejs_utils49 = require("@eeplatform/nodejs-utils");
+var import_mongodb29 = require("mongodb");
+function useSectionSubjectRepo() {
+  const db = import_nodejs_utils49.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "deped.section.subjects";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils49.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { school: 1 } },
+        { key: { section: 1 } },
+        { key: { teacher: 1 } },
+        { key: { subjectCode: 1 } },
+        { key: { schoolYear: 1 } },
+        { key: { gradeLevel: 1 } },
+        { key: { createdAt: 1 } },
+        {
+          key: {
+            subjectName: "text",
+            subjectCode: "text",
+            teacherName: "text"
+          }
+        },
+        {
+          key: {
+            school: 1,
+            section: 1,
+            subjectCode: 1,
+            schoolYear: 1,
+            status: 1
+          },
+          unique: true,
+          name: "unique_section_subject"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on section subjects.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils49.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils49.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelSectionSubject(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils49.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils49.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils49.BadRequestError("Section subject already exists.");
+        }
+        throw new Error("Failed to create section subject.");
       }
     }
-    return sizes;
   }
-  async function generateSections(value) {
-    const { error } = schemaGenerateSections.validate(value);
-    if (error) {
-      throw new import_nodejs_utils48.BadRequestError(
-        `Invalid section generation data: ${error.message}`
-      );
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active",
+    school = "",
+    section = "",
+    teacher = "",
+    schoolYear = "",
+    gradeLevel = "",
+    subjectCode = ""
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status: { $ne: "deleted" } };
+    const cacheKeyOptions = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (status) {
+      query.status = status;
+      cacheKeyOptions.status = status;
     }
-    const session = import_nodejs_utils48.useAtlas.getClient()?.startSession();
-    if (!session) {
-      throw new Error("Unable to start database session.");
+    if (school) {
+      try {
+        query.school = new import_mongodb29.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils49.BadRequestError("Invalid school ID.");
+      }
+      cacheKeyOptions.school = school;
+    }
+    if (section) {
+      try {
+        query.section = new import_mongodb29.ObjectId(section);
+      } catch (error) {
+        throw new import_nodejs_utils49.BadRequestError("Invalid section ID.");
+      }
+      cacheKeyOptions.section = section;
+    }
+    if (teacher) {
+      try {
+        query.teacher = new import_mongodb29.ObjectId(teacher);
+      } catch (error) {
+        throw new import_nodejs_utils49.BadRequestError("Invalid teacher ID.");
+      }
+      cacheKeyOptions.teacher = teacher;
+    }
+    if (schoolYear) {
+      query.schoolYear = schoolYear;
+      cacheKeyOptions.schoolYear = schoolYear;
     }
+    if (gradeLevel) {
+      query.gradeLevel = gradeLevel;
+      cacheKeyOptions.gradeLevel = gradeLevel;
+    }
+    if (subjectCode) {
+      query.subjectCode = subjectCode;
+      cacheKeyOptions.subjectCode = subjectCode;
+    }
+    sort = Object.keys(sort).length > 0 ? sort : { _id: 1 };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    const cacheKey = (0, import_nodejs_utils49.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils49.logger.log({
+      level: "info",
+      message: `Cache key for getAll section subjects: ${cacheKey}`
+    });
     try {
-      await session.startTransaction();
-      const studentCount = await getCountByGradeLevel(
-        {
-          school: value.school,
-          schoolYear: value.schoolYear,
-          gradeLevel: value.gradeLevel
-        },
-        session
-      );
-      if (studentCount === 0) {
-        throw new import_nodejs_utils48.BadRequestError("No learners found for this grade level.");
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache hit for getAll section subjects: ${cacheKey}`
+        });
+        return cached;
       }
-      const gradeLevelData = await getByGradeLevel(
-        {
-          school: value.school,
-          gradeLevel: value.gradeLevel
-        },
-        session
-      );
-      if (!gradeLevelData) {
-        throw new import_nodejs_utils48.BadRequestError("Grade level not found.");
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils49.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache set for getAll section subjects: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils49.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll section subjects: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils49.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb29.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils49.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils49.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache hit for getById section subject: ${cacheKey}`
+        });
+        return cached;
       }
-      const minPerSection = gradeLevelData.minNumberOfLearners;
-      const maxPerSection = gradeLevelData.maxNumberOfLearners;
-      const sectionsNeeded = Math.ceil(studentCount / minPerSection);
-      if (sectionsNeeded > value.set.length) {
-        throw new import_nodejs_utils48.BadRequestError(
-          "Insufficient number of section names in set[]."
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils49.BadRequestError("Section subject not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache set for section subject by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils49.logger.log({
+          level: "error",
+          message: `Failed to set cache for section subject by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils49.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils49.InternalServerError("Failed to get section subject.");
+      }
+    }
+  }
+  async function getBySection(section) {
+    try {
+      section = new import_mongodb29.ObjectId(section);
+    } catch (error) {
+      throw new import_nodejs_utils49.BadRequestError("Invalid section ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils49.makeCacheKey)(namespace_collection, {
+      section: String(section)
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache hit for getBySection section subjects: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.find({
+        section,
+        deletedAt: { $in: ["", null] }
+      }).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache set for section subjects by section: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils49.logger.log({
+          level: "error",
+          message: `Failed to set cache for section subjects by section: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils49.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils49.InternalServerError(
+          "Failed to get section subjects by section."
         );
       }
-      const sectionSizes = distributeStudents(
-        studentCount,
-        minPerSection,
-        maxPerSection
-      );
-      if (sectionSizes.length === 0) {
-        throw new import_nodejs_utils48.BadRequestError("Unable to compute section sizes.");
+    }
+  }
+  async function getByTeacher(teacher) {
+    try {
+      teacher = new import_mongodb29.ObjectId(teacher);
+    } catch (error) {
+      throw new import_nodejs_utils49.BadRequestError("Invalid teacher ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils49.makeCacheKey)(namespace_collection, {
+      teacher: String(teacher)
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache hit for getByTeacher section subjects: ${cacheKey}`
+        });
+        return cached;
       }
-      let pointer = 0;
-      for (let i = 0; i < sectionSizes.length; i++) {
-        const size = sectionSizes[i];
-        const sectionName = value.set[i];
-        const section = await createSection(
-          {
-            school: value.school,
-            schoolYear: value.schoolYear,
-            gradeLevel: value.gradeLevel,
-            name: sectionName,
-            students: size
-          },
-          session
+      const result = await collection.find({
+        teacher,
+        deletedAt: { $in: ["", null] }
+      }).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache set for section subjects by teacher: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils49.logger.log({
+          level: "error",
+          message: `Failed to set cache for section subjects by teacher: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils49.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils49.InternalServerError(
+          "Failed to get section subjects by teacher."
         );
-        const learners = await getLeanerByGradeLevel(
-          {
-            school: value.school,
-            gradeLevel: value.gradeLevel,
-            skip: pointer,
-            limit: size
-          },
-          session
+      }
+    }
+  }
+  async function getBySchool(school) {
+    try {
+      school = new import_mongodb29.ObjectId(school);
+    } catch (error) {
+      throw new import_nodejs_utils49.BadRequestError("Invalid school ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils49.makeCacheKey)(namespace_collection, {
+      school: String(school)
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache hit for getBySchool section subjects: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.find({
+        school,
+        deletedAt: { $in: ["", null] }
+      }).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils49.logger.log({
+          level: "info",
+          message: `Cache set for section subjects by school: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils49.logger.log({
+          level: "error",
+          message: `Failed to set cache for section subjects by school: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils49.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils49.InternalServerError(
+          "Failed to get section subjects by school."
         );
-        if (!learners.length) {
-          throw new import_nodejs_utils48.BadRequestError(`No learners found for section #${i + 1}.`);
-        }
-        pointer += size;
-        for (const student of learners) {
-          if (!student._id) {
-            throw new import_nodejs_utils48.BadRequestError("Learner ID is missing.");
-          }
-          await assignStudent(
-            {
-              section: section.toString(),
-              student: student._id?.toString(),
-              studentName: `${student.learnerInfo.firstName} ${student.learnerInfo.lastName}`,
-              status: "active"
-            },
-            session
-          );
-        }
       }
-      await session.commitTransaction();
-      return "Sections generated successfully.";
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = [
+      "teacher",
+      "teacherName",
+      "classroom",
+      "schedule",
+      "daysOfWeek"
+    ];
+    if (!allowedFields.includes(field)) {
+      throw new import_nodejs_utils49.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb29.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils49.BadRequestError("Invalid ID.");
+    }
+    if (field === "teacher" && value) {
+      try {
+        value = new import_mongodb29.ObjectId(value).toString();
+      } catch (error) {
+        throw new import_nodejs_utils49.BadRequestError("Invalid teacher ID.");
+      }
+    }
+    try {
+      const updateValue = field === "teacher" ? new import_mongodb29.ObjectId(value) : value;
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { [field]: updateValue, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated section subject ${field}.`;
+    } catch (error) {
+      throw new import_nodejs_utils49.InternalServerError(
+        `Failed to update section subject ${field}.`
+      );
+    }
+  }
+  async function setupById(_id, value, session) {
+    const { error } = schemaSectionSubjectSetup.validate(value);
+    if (error) {
+      throw new import_nodejs_utils49.BadRequestError(
+        `Invalid section subject data: ${error.message}`
+      );
+    }
+    try {
+      _id = new import_mongodb29.ObjectId(_id);
     } catch (error2) {
-      await session.abortTransaction();
-      if (error2 instanceof import_nodejs_utils48.AppError) {
+      throw new import_nodejs_utils49.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { ...value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated section subject.`;
+    } catch (error2) {
+      throw new import_nodejs_utils49.InternalServerError(`Failed to update section subject.`);
+    }
+  }
+  async function deleteById(_id) {
+    try {
+      _id = new import_mongodb29.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils49.BadRequestError("Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } }
+      );
+      delCachedData();
+      return "Successfully deleted section subject.";
+    } catch (error) {
+      throw new import_nodejs_utils49.InternalServerError("Failed to delete section subject.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getBySection,
+    getByTeacher,
+    getBySchool,
+    updateFieldById,
+    setupById,
+    deleteById
+  };
+}
+
+// src/resources/section-subject/section.subject.service.ts
+var import_nodejs_utils50 = require("@eeplatform/nodejs-utils");
+function useSectionSubjectService() {
+  const { getById: getSchoolById } = useSchoolRepo();
+  const { add: _add } = useSectionSubjectRepo();
+  async function add(value) {
+    const { error } = schemaSectionSubject.validate(value);
+    if (error) {
+      throw new Error(`Invalid section subject data: ${error.message}`);
+    }
+    try {
+      const school = await getSchoolById(value.school);
+      if (!school) {
+        throw new Error("School not found.");
+      }
+      if (!school.name) {
+        throw new Error("School name is missing.");
+      }
+      value.schoolName = school.name;
+      await _add(value);
+      return "Successfully created section subject.";
+    } catch (error2) {
+      if (error2 instanceof import_nodejs_utils50.AppError) {
         throw error2;
       } else {
-        throw new import_nodejs_utils48.InternalServerError("Failed to generate sections.");
+        throw new import_nodejs_utils50.InternalServerError("Failed to create section subject.");
       }
-    } finally {
-      await session?.endSession();
     }
   }
-  return { generateSections };
+  return {
+    add
+  };
 }
 
-// src/resources/section/section.controller.ts
-function useSectionController() {
+// src/resources/section-subject/section.subject.controller.ts
+var import_nodejs_utils51 = require("@eeplatform/nodejs-utils");
+var import_joi30 = __toESM(require("joi"));
+function useSectionSubjectController() {
   const {
-    add: _add,
     getAll: _getAll,
     getById: _getById,
-    getByName: _getByName,
+    getBySection: _getBySection,
+    getByTeacher: _getByTeacher,
     getBySchool: _getBySchool,
     updateFieldById: _updateFieldById,
-    addStudentToSection: _addStudentToSection,
-    removeStudentFromSection: _removeStudentFromSection,
-    deleteById: _deleteById
-  } = useSectionRepo();
-  const { generateSections: _generateSections } = useSectionService();
+    deleteById: _deleteById,
+    setupById: _setupById
+  } = useSectionSubjectRepo();
+  const { add: _add } = useSectionSubjectService();
   async function add(req, res, next) {
     const value = req.body;
-    const { error } = schemaSection.validate(value);
+    const { error } = schemaSectionSubject.validate(value);
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils51.BadRequestError(error.message));
       return;
     }
     try {
       const data = await _add(value);
       res.json({
-        message: "Successfully created section.",
-        data
-      });
-      return;
-    } catch (error2) {
-      next(error2);
-    }
-  }
-  async function generateSections(req, res, next) {
-    const value = req.body;
-    const { error } = schemaGenerateSections.validate(value);
-    if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const data = await _generateSections(value);
-      res.json({
-        message: "Successfully created section.",
+        message: "Successfully created section subject.",
         data
       });
       return;
@@ -38148,35 +38592,41 @@ function useSectionController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi29.default.object({
-      page: import_joi29.default.number().min(1).optional().allow("", null),
-      limit: import_joi29.default.number().min(1).optional().allow("", null),
-      search: import_joi29.default.string().optional().allow("", null),
-      status: import_joi29.default.string().optional().allow("", null),
-      school: import_joi29.default.string().hex().optional().allow("", null),
-      schoolYear: import_joi29.default.string().optional().allow("", null),
-      gradeLevel: import_joi29.default.string().optional().allow("", null)
+    const validation = import_joi30.default.object({
+      page: import_joi30.default.number().min(1).optional().allow("", null),
+      limit: import_joi30.default.number().min(1).optional().allow("", null),
+      search: import_joi30.default.string().optional().allow("", null),
+      status: import_joi30.default.string().optional().allow("", null),
+      school: import_joi30.default.string().hex().optional().allow("", null),
+      section: import_joi30.default.string().hex().optional().allow("", null),
+      teacher: import_joi30.default.string().hex().optional().allow("", null),
+      schoolYear: import_joi30.default.string().optional().allow("", null),
+      gradeLevel: import_joi30.default.string().optional().allow("", null),
+      subjectCode: import_joi30.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(query);
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
     const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
     const search = req.query.search ?? "";
-    const status = req.query.status ?? "active";
+    const status = req.query.status ?? "";
     const school = req.query.school ?? "";
+    const section = req.query.section ?? "";
+    const teacher = req.query.teacher ?? "";
     const schoolYear = req.query.schoolYear ?? "";
     const gradeLevel = req.query.gradeLevel ?? "";
+    const subjectCode = req.query.subjectCode ?? "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_nodejs_utils49.BadRequestError("Invalid page number."));
+      next(new import_nodejs_utils51.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_nodejs_utils49.BadRequestError("Invalid limit number."));
+      next(new import_nodejs_utils51.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils51.BadRequestError(error.message));
       return;
     }
     try {
@@ -38186,8 +38636,11 @@ function useSectionController() {
         search,
         status,
         school,
+        section,
+        teacher,
         schoolYear,
-        gradeLevel
+        gradeLevel,
+        subjectCode
       });
       res.json(data);
       return;
@@ -38197,18 +38650,386 @@ function useSectionController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi29.default.object({
-      id: import_joi29.default.string().hex().required()
+    const validation = import_joi30.default.object({
+      id: import_joi30.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils51.BadRequestError(error.message));
       return;
     }
     try {
       const data = await _getById(id);
       res.json({
-        message: "Successfully retrieved section.",
+        message: "Successfully retrieved section subject.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getBySection(req, res, next) {
+    const section = req.params.section;
+    const validation = import_joi30.default.object({
+      section: import_joi30.default.string().hex().required()
+    });
+    const { error } = validation.validate({ section });
+    if (error) {
+      next(new import_nodejs_utils51.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getBySection(section);
+      res.json({
+        message: "Successfully retrieved section subjects.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByTeacher(req, res, next) {
+    const teacher = req.params.teacher;
+    const validation = import_joi30.default.object({
+      teacher: import_joi30.default.string().hex().required()
+    });
+    const { error } = validation.validate({ teacher });
+    if (error) {
+      next(new import_nodejs_utils51.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getByTeacher(teacher);
+      res.json({
+        message: "Successfully retrieved section subjects.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getBySchool(req, res, next) {
+    const school = req.params.school;
+    const validation = import_joi30.default.object({
+      school: import_joi30.default.string().hex().required()
+    });
+    const { error } = validation.validate({ school });
+    if (error) {
+      next(new import_nodejs_utils51.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getBySchool(school);
+      res.json({
+        message: "Successfully retrieved section subjects.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateField(req, res, next) {
+    const _id = req.params.id;
+    const { field, value } = req.body;
+    const validation = import_joi30.default.object({
+      _id: import_joi30.default.string().hex().required(),
+      field: import_joi30.default.string().valid(
+        "subjectCode",
+        "subjectName",
+        "teacher",
+        "teacherName",
+        "classroom",
+        "schedule"
+      ).required(),
+      value: import_joi30.default.string().required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new import_nodejs_utils51.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateFieldById({ _id, field, value });
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function setupById(req, res, next) {
+    const _id = req.params.id;
+    const data = req.body;
+    const { error } = schemaSectionSubjectSetup.validate(data);
+    if (error) {
+      next(new import_nodejs_utils51.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _setupById(_id, data);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const _id = req.params.id;
+    const validation = import_joi30.default.object({
+      _id: import_joi30.default.string().hex().required()
+    });
+    const { error } = validation.validate({ _id });
+    if (error) {
+      next(new import_nodejs_utils51.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(_id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    getBySection,
+    getByTeacher,
+    getBySchool,
+    updateField,
+    setupById,
+    deleteById
+  };
+}
+
+// src/resources/section/section.service.ts
+function useSectionService() {
+  const { getCountByGradeLevel, getByGradeLevel: getLeanerByGradeLevel } = useLearnerRepo();
+  const { getByGradeLevel } = useGradeLevelRepo();
+  const { add: createSection } = useSectionRepo();
+  const { add: assignStudent } = useSectionStudentRepo();
+  const { getAll: getAllCurriculumSubjects } = useCurriculumSubjectRepo();
+  const { add: addSectionSubject } = useSectionSubjectRepo();
+  function distributeStudents(total, minPer, maxPer) {
+    if (total <= 0)
+      return [];
+    if (minPer <= 0 || maxPer <= 0)
+      return [];
+    if (minPer > maxPer) {
+      throw new import_nodejs_utils52.BadRequestError(
+        "Minimum students per section cannot be greater than maximum."
+      );
+    }
+    const minSections = Math.ceil(total / maxPer);
+    const maxSections = Math.floor(total / minPer);
+    let sectionCount;
+    if (minSections <= maxSections) {
+      sectionCount = minSections;
+    } else {
+      sectionCount = minSections;
+    }
+    const base = Math.floor(total / sectionCount);
+    const extra = total % sectionCount;
+    const sizes = new Array(sectionCount).fill(base);
+    for (let i = 0; i < extra; i++) {
+      sizes[i] += 1;
+    }
+    for (const size of sizes) {
+      if (size > maxPer) {
+        throw new import_nodejs_utils52.BadRequestError(
+          `Generated section exceeds max limit of ${maxPer}.`
+        );
+      }
+    }
+    return sizes;
+  }
+  async function generateSections(value) {
+    const { error } = schemaGenerateSections.validate(value);
+    if (error) {
+      throw new import_nodejs_utils52.BadRequestError(
+        `Invalid section generation data: ${error.message}`
+      );
+    }
+    const session = import_nodejs_utils52.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Unable to start database session.");
+    }
+    try {
+      await session.startTransaction();
+      const studentCount = await getCountByGradeLevel(
+        {
+          school: value.school,
+          schoolYear: value.schoolYear,
+          gradeLevel: value.gradeLevel
+        },
+        session
+      );
+      if (studentCount === 0) {
+        throw new import_nodejs_utils52.BadRequestError("No learners found for this grade level.");
+      }
+      const gradeLevelData = await getByGradeLevel(
+        {
+          school: value.school,
+          gradeLevel: value.gradeLevel
+        },
+        session
+      );
+      if (!gradeLevelData) {
+        throw new import_nodejs_utils52.BadRequestError("Grade level not found.");
+      }
+      const minPerSection = gradeLevelData.minNumberOfLearners;
+      const maxPerSection = gradeLevelData.maxNumberOfLearners;
+      const sectionsNeeded = Math.ceil(studentCount / minPerSection);
+      if (sectionsNeeded > value.set.length) {
+        throw new import_nodejs_utils52.BadRequestError(
+          "Insufficient number of section names in set[]."
+        );
+      }
+      const sectionSizes = distributeStudents(
+        studentCount,
+        minPerSection,
+        maxPerSection
+      );
+      if (sectionSizes.length === 0) {
+        throw new import_nodejs_utils52.BadRequestError("Unable to compute section sizes.");
+      }
+      let totalStudentsProcessed = 0;
+      for (let i = 0; i < sectionSizes.length; i++) {
+        const size = sectionSizes[i];
+        const sectionName = value.set[i];
+        const section = await createSection(
+          {
+            school: value.school,
+            schoolYear: value.schoolYear,
+            gradeLevel: value.gradeLevel,
+            name: sectionName,
+            students: size
+          },
+          session
+        );
+        const skip = totalStudentsProcessed;
+        const learners = await getLeanerByGradeLevel(
+          {
+            school: value.school,
+            gradeLevel: value.gradeLevel,
+            skip,
+            limit: size
+          },
+          session
+        );
+        if (!learners.length) {
+          throw new import_nodejs_utils52.BadRequestError(`No learners found for section #${i + 1}.`);
+        }
+        totalStudentsProcessed += learners.length;
+        for (const student of learners) {
+          if (!student._id) {
+            throw new import_nodejs_utils52.BadRequestError("Learner ID is missing.");
+          }
+          await assignStudent(
+            {
+              section: section.toString(),
+              student: student._id?.toString(),
+              studentName: `${student.learnerInfo.firstName} ${student.learnerInfo.lastName}`,
+              status: "active"
+            },
+            session
+          );
+        }
+        const curriculumSubjects = await getAllCurriculumSubjects({
+          schoolYear: Number(value.schoolYear),
+          gradeLevel: value.gradeLevel,
+          limit: 20
+        });
+        for (const curriculumSubject of curriculumSubjects.items) {
+          await addSectionSubject(
+            {
+              school: value.school,
+              schoolName: "",
+              gradeLevel: value.gradeLevel,
+              educationLevel: gradeLevelData.educationLevel,
+              schoolYear: value.schoolYear,
+              section: section.toString(),
+              sectionName,
+              subjectCode: curriculumSubject.subjectCode,
+              subjectName: curriculumSubject.subjectName,
+              teacher: "",
+              teacherName: "",
+              schedule: "",
+              daysOfWeek: [],
+              classroom: "",
+              classroomName: "",
+              sessionDuration: curriculumSubject.sessionDuration,
+              sessionFrequency: curriculumSubject.sessionFrequency,
+              status: "draft"
+            },
+            session
+          );
+        }
+      }
+      await session.commitTransaction();
+      return "Sections generated successfully.";
+    } catch (error2) {
+      await session.abortTransaction();
+      if (error2 instanceof import_nodejs_utils52.AppError) {
+        throw error2;
+      } else {
+        throw new import_nodejs_utils52.InternalServerError("Failed to generate sections.");
+      }
+    } finally {
+      await session?.endSession();
+    }
+  }
+  return { generateSections };
+}
+
+// src/resources/section/section.controller.ts
+function useSectionController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    getByName: _getByName,
+    getBySchool: _getBySchool,
+    updateFieldById: _updateFieldById,
+    addStudentToSection: _addStudentToSection,
+    removeStudentFromSection: _removeStudentFromSection,
+    deleteById: _deleteById
+  } = useSectionRepo();
+  const { generateSections: _generateSections } = useSectionService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaSection.validate(value);
+    if (error) {
+      next(new import_nodejs_utils53.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _add(value);
+      res.json({
+        message: "Successfully created section.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function generateSections(req, res, next) {
+    const value = req.body;
+    const { error } = schemaGenerateSections.validate(value);
+    if (error) {
+      next(new import_nodejs_utils53.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _generateSections(value);
+      res.json({
+        message: "Successfully created section.",
         data
       });
       return;
@@ -38216,14 +39037,81 @@ function useSectionController() {
       next(error2);
     }
   }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi31.default.object({
+      page: import_joi31.default.number().min(1).optional().allow("", null),
+      limit: import_joi31.default.number().min(1).optional().allow("", null),
+      search: import_joi31.default.string().optional().allow("", null),
+      status: import_joi31.default.string().optional().allow("", null),
+      school: import_joi31.default.string().hex().optional().allow("", null),
+      schoolYear: import_joi31.default.string().optional().allow("", null),
+      gradeLevel: import_joi31.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    const school = req.query.school ?? "";
+    const schoolYear = req.query.schoolYear ?? "";
+    const gradeLevel = req.query.gradeLevel ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils53.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils53.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_nodejs_utils53.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll({
+        page,
+        limit,
+        search,
+        status,
+        school,
+        schoolYear,
+        gradeLevel
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi31.default.object({
+      id: import_joi31.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils53.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = import_joi29.default.object({
-      name: import_joi29.default.string().required()
+    const validation = import_joi31.default.object({
+      name: import_joi31.default.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -38239,12 +39127,12 @@ function useSectionController() {
   }
   async function getBySchool(req, res, next) {
     const school = req.params.school;
-    const validation = import_joi29.default.object({
-      school: import_joi29.default.string().hex().required()
+    const validation = import_joi31.default.object({
+      school: import_joi31.default.string().hex().required()
     });
     const { error } = validation.validate({ school });
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -38261,14 +39149,14 @@ function useSectionController() {
   async function updateField(req, res, next) {
     const _id = req.params.id;
     const { field, value } = req.body;
-    const validation = import_joi29.default.object({
-      _id: import_joi29.default.string().hex().required(),
-      field: import_joi29.default.string().valid("name", "schoolYear", "gradeLevel", "adviser", "adviserName").required(),
-      value: import_joi29.default.string().required()
+    const validation = import_joi31.default.object({
+      _id: import_joi31.default.string().hex().required(),
+      field: import_joi31.default.string().valid("name", "schoolYear", "gradeLevel", "adviser", "adviserName").required(),
+      value: import_joi31.default.string().required()
     });
     const { error } = validation.validate({ _id, field, value });
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -38282,13 +39170,13 @@ function useSectionController() {
   async function addStudent(req, res, next) {
     const _id = req.params.id;
     const { studentId } = req.body;
-    const validation = import_joi29.default.object({
-      _id: import_joi29.default.string().hex().required(),
-      studentId: import_joi29.default.string().required()
+    const validation = import_joi31.default.object({
+      _id: import_joi31.default.string().hex().required(),
+      studentId: import_joi31.default.string().required()
     });
     const { error } = validation.validate({ _id, studentId });
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -38302,13 +39190,13 @@ function useSectionController() {
   async function removeStudent(req, res, next) {
     const _id = req.params.id;
     const { studentId } = req.body;
-    const validation = import_joi29.default.object({
-      _id: import_joi29.default.string().hex().required(),
-      studentId: import_joi29.default.string().required()
+    const validation = import_joi31.default.object({
+      _id: import_joi31.default.string().hex().required(),
+      studentId: import_joi31.default.string().required()
     });
     const { error } = validation.validate({ _id, studentId });
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -38321,12 +39209,12 @@ function useSectionController() {
   }
   async function deleteById(req, res, next) {
     const _id = req.params.id;
-    const validation = import_joi29.default.object({
-      _id: import_joi29.default.string().hex().required()
+    const validation = import_joi31.default.object({
+      _id: import_joi31.default.string().hex().required()
     });
     const { error } = validation.validate({ _id });
     if (error) {
-      next(new import_nodejs_utils49.BadRequestError(error.message));
+      next(new import_nodejs_utils53.BadRequestError(error.message));
       return;
     }
     try {
@@ -38351,16 +39239,1692 @@ function useSectionController() {
   };
 }
 
+// src/resources/building/building.model.ts
+var import_nodejs_utils54 = require("@eeplatform/nodejs-utils");
+var import_joi32 = __toESM(require("joi"));
+var import_mongodb30 = require("mongodb");
+var schemaBuilding = import_joi32.default.object({
+  _id: import_joi32.default.string().hex().optional(),
+  school: import_joi32.default.string().hex().required(),
+  serial: import_joi32.default.string().optional().allow("", null),
+  name: import_joi32.default.string().required(),
+  levels: import_joi32.default.number().integer().min(1).required(),
+  createdAt: import_joi32.default.date().optional().allow("", null),
+  updatedAt: import_joi32.default.date().optional().allow("", null),
+  deletedAt: import_joi32.default.date().optional().allow("", null),
+  status: import_joi32.default.string().optional().allow("", null)
+});
+var schemaBuildingUnit = import_joi32.default.object({
+  _id: import_joi32.default.string().hex().optional(),
+  school: import_joi32.default.string().hex().required(),
+  name: import_joi32.default.string().optional().allow("", null),
+  building: import_joi32.default.string().hex().required(),
+  buildingName: import_joi32.default.string().optional().allow("", null),
+  level: import_joi32.default.number().integer().min(1).required(),
+  category: import_joi32.default.string().required(),
+  type: import_joi32.default.string().required(),
+  seating_capacity: import_joi32.default.number().integer().min(0).required(),
+  standing_capacity: import_joi32.default.number().integer().min(0).required(),
+  description: import_joi32.default.string().optional().allow("", null),
+  unit_of_measurement: import_joi32.default.string().valid("sqm").required(),
+  area: import_joi32.default.number().positive().required(),
+  status: import_joi32.default.string().optional().allow("", null)
+});
+var schemaUpdateOptions = import_joi32.default.object({
+  name: import_joi32.default.string().optional().allow("", null),
+  building: import_joi32.default.string().hex().optional().allow("", null),
+  buildingName: import_joi32.default.string().optional().allow("", null),
+  level: import_joi32.default.number().integer().min(1).optional().allow("", null),
+  category: import_joi32.default.string().optional().allow("", null),
+  type: import_joi32.default.string().optional().allow("", null),
+  seating_capacity: import_joi32.default.number().integer().min(0).optional().allow("", null),
+  standing_capacity: import_joi32.default.number().integer().min(0).optional().allow("", null),
+  area: import_joi32.default.number().positive().optional().allow("", null)
+});
+function MBuilding(value) {
+  const { error } = schemaBuilding.validate(value);
+  if (error) {
+    import_nodejs_utils54.logger.info(`Building Model: ${error.message}`);
+    throw new import_nodejs_utils54.BadRequestError(error.message);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb30.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_nodejs_utils54.BadRequestError("Invalid _id format");
+    }
+  }
+  try {
+    value.school = new import_mongodb30.ObjectId(value.school);
+  } catch (error2) {
+    throw new import_nodejs_utils54.BadRequestError("Invalid school format");
+  }
+  return {
+    _id: value._id ?? void 0,
+    school: value.school,
+    serial: value.serial ?? "",
+    name: value.name ?? "",
+    levels: value.levels ?? 0,
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+function MBuildingUnit(value) {
+  const { error } = schemaBuildingUnit.validate(value);
+  if (error) {
+    import_nodejs_utils54.logger.info(`Building Unit Model: ${error.message}`);
+    throw new import_nodejs_utils54.BadRequestError(error.message);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb30.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_nodejs_utils54.BadRequestError("Invalid ID");
+    }
+  }
+  try {
+    value.school = new import_mongodb30.ObjectId(value.school);
+  } catch (error2) {
+    throw new import_nodejs_utils54.BadRequestError("Invalid school ID");
+  }
+  try {
+    value.building = new import_mongodb30.ObjectId(value.building);
+  } catch (error2) {
+    throw new import_nodejs_utils54.BadRequestError("Invalid building ID");
+  }
+  return {
+    _id: value._id ?? void 0,
+    school: value.school,
+    name: value.name ?? "",
+    building: value.building,
+    buildingName: value.buildingName ?? "",
+    level: value.level ?? 0,
+    category: value.category ?? "",
+    type: value.type ?? "",
+    seating_capacity: value.seating_capacity ?? 0,
+    standing_capacity: value.standing_capacity ?? 0,
+    description: value.description ?? "",
+    unit_of_measurement: value.unit_of_measurement ?? "sqm",
+    area: value.area ?? 0,
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/resources/building/building.repository.ts
+var import_nodejs_utils55 = require("@eeplatform/nodejs-utils");
+var import_mongodb31 = require("mongodb");
+function useBuildingRepo() {
+  const db = import_nodejs_utils55.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "school.buildings";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils55.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { name: 1 }, unique: true, name: "unique_name_index" },
+        { key: { school: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on buildings.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MBuilding(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils55.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils55.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils55.BadRequestError("Building already exists.");
+        }
+        throw new Error("Failed to create building.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb31.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils55.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils55.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils55.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to update building.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    school = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    if (school) {
+      try {
+        query.school = new import_mongodb31.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils55.BadRequestError("Invalid school ID.");
+      }
+    }
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search)
+      cacheParams.search = search;
+    if (school)
+      cacheParams.school = school;
+    if (status !== "active")
+      cacheParams.status = status;
+    const cacheKey = (0, import_nodejs_utils55.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils55.logger.log({
+      level: "info",
+      message: `Cache key for getAll buildings: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils55.logger.log({
+          level: "info",
+          message: `Cache hit for getAll buildings: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils55.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils55.logger.log({
+          level: "info",
+          message: `Cache set for getAll buildings: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils55.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll buildings: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils55.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb31.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils55.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils55.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils55.logger.log({
+          level: "info",
+          message: `Cache hit for getById building: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils55.logger.log({
+          level: "info",
+          message: `Cache set for building by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils55.logger.log({
+          level: "error",
+          message: `Failed to set cache for building by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils55.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils55.InternalServerError("Failed to get building.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb31.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils55.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils55.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils55.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils55.InternalServerError("Failed to delete building.");
+      }
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils55.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils55.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/building/building.service.ts
+var import_nodejs_utils57 = require("@eeplatform/nodejs-utils");
+
+// src/resources/building/building-unit.repository.ts
+var import_nodejs_utils56 = require("@eeplatform/nodejs-utils");
+var import_mongodb32 = require("mongodb");
+function useBuildingUnitRepo() {
+  const db = import_nodejs_utils56.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "school.building-units";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils56.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: { name: 1, building: 1, level: 1 },
+          unique: true,
+          name: "unique_name_index"
+        },
+        { key: { school: 1 } },
+        { key: { building: 1 } },
+        { key: { status: 1 } },
+        { key: { createdAt: 1 } },
+        {
+          key: {
+            name: "text",
+            buildingName: "text",
+            category: "text",
+            type: "text"
+          }
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on building units.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils56.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils56.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = MBuildingUnit(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils56.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils56.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to create building unit.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    const { error } = schemaUpdateOptions.validate(value);
+    if (error) {
+      throw new import_nodejs_utils56.BadRequestError(error.message);
+    }
+    try {
+      _id = new import_mongodb32.ObjectId(_id);
+    } catch (error2) {
+      throw new import_nodejs_utils56.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error2) {
+      import_nodejs_utils56.logger.log({
+        level: "error",
+        message: error2.message
+      });
+      if (error2 instanceof import_nodejs_utils56.AppError) {
+        throw error2;
+      } else {
+        throw new Error("Failed to create building unit.");
+      }
+    }
+  }
+  async function updateByBuildingId(building, value, session) {
+    const { error } = schemaUpdateOptions.validate(value);
+    if (error) {
+      throw new import_nodejs_utils56.BadRequestError(error.message);
+    }
+    try {
+      building = new import_mongodb32.ObjectId(building);
+    } catch (error2) {
+      throw new import_nodejs_utils56.BadRequestError("Invalid building ID.");
+    }
+    try {
+      const res = await collection.updateMany(
+        { building },
+        { $set: value },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error2) {
+      import_nodejs_utils56.logger.log({
+        level: "error",
+        message: error2.message
+      });
+      if (error2 instanceof import_nodejs_utils56.AppError) {
+        throw error2;
+      } else {
+        throw new Error("Failed to update building unit.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    school = "",
+    building = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      deletedAt: { $in: ["", null] },
+      status: { $in: [status, "", null] }
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    if (school) {
+      try {
+        query.school = new import_mongodb32.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils56.BadRequestError("Invalid school ID.");
+      }
+    }
+    if (building) {
+      try {
+        query.building = new import_mongodb32.ObjectId(building);
+      } catch (error) {
+        throw new import_nodejs_utils56.BadRequestError("Invalid building ID.");
+      }
+    }
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search)
+      cacheParams.search = search;
+    if (school)
+      cacheParams.school = school;
+    if (building)
+      cacheParams.building = building;
+    if (status !== "active")
+      cacheParams.status = status;
+    const cacheKey = (0, import_nodejs_utils56.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils56.logger.log({
+      level: "info",
+      message: `Cache key for getAll building units: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache hit for getAll building units: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils56.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache set for getAll building units: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils56.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll building units: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils56.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb32.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils56.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils56.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache hit for getById building unit: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils56.BadRequestError("Building unit not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache set for building unit by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils56.logger.log({
+          level: "error",
+          message: `Failed to set cache for building unit by id: ${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 building unit.");
+      }
+    }
+  }
+  async function getByBuildingLevel(building, level) {
+    try {
+      building = new import_mongodb32.ObjectId(building);
+    } catch (error) {
+      throw new import_nodejs_utils56.BadRequestError("Invalid building ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils56.makeCacheKey)(namespace_collection, {
+      building: String(building),
+      level
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache hit for getById building unit: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        building,
+        level,
+        status: "active"
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache set for building unit by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils56.logger.log({
+          level: "error",
+          message: `Failed to set cache for building unit by id: ${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 building unit.");
+      }
+    }
+  }
+  async function getByBuilding(building) {
+    try {
+      building = new import_mongodb32.ObjectId(building);
+    } catch (error) {
+      throw new import_nodejs_utils56.BadRequestError("Invalid building ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils56.makeCacheKey)(namespace_collection, {
+      building: String(building)
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache hit for getById building unit: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        building,
+        status: "active"
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils56.logger.log({
+          level: "info",
+          message: `Cache set for building unit by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils56.logger.log({
+          level: "error",
+          message: `Failed to set cache for building unit by id: ${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 building unit.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb32.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils56.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+      return "Room/Facility deleted successfully.";
+    } catch (error) {
+      import_nodejs_utils56.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils56.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to deleted room/facility.");
+      }
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getByBuildingLevel,
+    updateById,
+    getByBuilding,
+    deleteById,
+    updateByBuildingId
+  };
+}
+
+// src/resources/building/building.service.ts
+function useBuildingService() {
+  const {
+    updateById: _updateById,
+    getById: _getById,
+    deleteById: _deleteById
+  } = useBuildingRepo();
+  const { getByBuildingLevel, getByBuilding, updateByBuildingId } = useBuildingUnitRepo();
+  async function updateById(id, data) {
+    data.levels = Number(data.levels);
+    const session = import_nodejs_utils57.useAtlas.getClient()?.startSession();
+    try {
+      const building = await _getById(id);
+      if (!building) {
+        throw new import_nodejs_utils57.NotFoundError("Building not found.");
+      }
+      if (data.levels < building.levels) {
+        const unit = await getByBuildingLevel(id, building.levels);
+        if (unit) {
+          throw new import_nodejs_utils57.BadRequestError(
+            "Cannot reduce floors, there are existing building units at higher floors."
+          );
+        }
+      }
+      session?.startTransaction();
+      if (building.name !== data.name) {
+        await updateByBuildingId(id, { buildingName: data.name }, session);
+      }
+      const result = await _updateById(id, data, session);
+      await session?.commitTransaction();
+      return result;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
+  async function deleteById(id) {
+    const building = await getByBuilding(id);
+    if (building) {
+      throw new import_nodejs_utils57.BadRequestError(
+        "Cannot delete building with existing room/facility. Please delete room/facility first."
+      );
+    }
+    try {
+      await _deleteById(id);
+      return "Building deleted successfully.";
+    } catch (error) {
+      throw error;
+    }
+  }
+  return {
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/building/building.controller.ts
+var import_nodejs_utils58 = require("@eeplatform/nodejs-utils");
+var import_joi33 = __toESM(require("joi"));
+function useBuildingController() {
+  const { getAll: _getAll, getById: _getById, add: _add } = useBuildingRepo();
+  const { updateById: _updateById, deleteById: _deleteById } = useBuildingService();
+  async function createBuilding(req, res, next) {
+    const value = req.body;
+    const validation = import_joi33.default.object({
+      name: import_joi33.default.string().required(),
+      school: import_joi33.default.string().hex().required(),
+      levels: import_joi33.default.number().integer().min(1).required(),
+      serial: import_joi33.default.string().optional().allow("", null),
+      status: import_joi33.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_nodejs_utils58.BadRequestError(error.message));
+      import_nodejs_utils58.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _add(value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const value = req.body;
+    const id = req.params.id ?? "";
+    const validation = import_joi33.default.object({
+      id: import_joi33.default.string().hex().required(),
+      value: import_joi33.default.object({
+        name: import_joi33.default.string().required(),
+        serial: import_joi33.default.string().optional().allow("", null),
+        levels: import_joi33.default.number().integer().min(1).required()
+      })
+    });
+    const { error } = validation.validate({ id, value });
+    if (error) {
+      next(new import_nodejs_utils58.BadRequestError(error.message));
+      import_nodejs_utils58.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _updateById(id, value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi33.default.object({
+      page: import_joi33.default.number().min(1).optional().allow("", null),
+      limit: import_joi33.default.number().min(1).optional().allow("", null),
+      search: import_joi33.default.string().optional().allow("", null),
+      school: import_joi33.default.string().hex().optional().allow("", null),
+      status: import_joi33.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils58.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const status = req.query.status ?? "active";
+    const school = req.query.school ?? "";
+    const search = req.query.search ?? "";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        status,
+        school,
+        search
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi33.default.object({
+      id: import_joi33.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils58.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const building = await _getById(id);
+      res.json({
+        message: "Successfully retrieved building.",
+        data: { building }
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi33.default.object({
+      id: import_joi33.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils58.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json(message);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    createBuilding,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/building/building-unit.service.ts
+var import_nodejs_utils59 = require("@eeplatform/nodejs-utils");
+function useBuildingUnitService() {
+  const { add: _add } = useBuildingUnitRepo();
+  async function add(value) {
+    const session = import_nodejs_utils59.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Unable to start session for building unit service.");
+    }
+    try {
+      await session.startTransaction();
+      for (let index = 0; index < value.qty; index++) {
+        await _add(
+          { ...value.building, name: `${value.building.name} ${index + 1}` },
+          session
+        );
+      }
+      await session.commitTransaction();
+      return "Building unit added successfully.";
+    } catch (error) {
+      await session.abortTransaction();
+      throw error;
+    } finally {
+      session.endSession();
+    }
+  }
+  return {
+    add
+  };
+}
+
+// src/resources/building/building-unit.controller.ts
+var import_nodejs_utils60 = require("@eeplatform/nodejs-utils");
+var import_joi34 = __toESM(require("joi"));
+function useBuildingUnitController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    updateById: _updateById,
+    deleteById: _deleteById
+  } = useBuildingUnitRepo();
+  const { add: _add } = useBuildingUnitService();
+  async function add(req, res, next) {
+    const data = req.body;
+    const validation = import_joi34.default.object({
+      building: import_joi34.default.object({
+        school: import_joi34.default.string().hex().required(),
+        name: import_joi34.default.string().optional().allow("", null),
+        building: import_joi34.default.string().hex().required(),
+        buildingName: import_joi34.default.string().optional().allow("", null),
+        level: import_joi34.default.number().integer().min(1).required(),
+        category: import_joi34.default.string().required(),
+        type: import_joi34.default.string().required(),
+        seating_capacity: import_joi34.default.number().integer().min(0).required(),
+        standing_capacity: import_joi34.default.number().integer().min(0).required(),
+        description: import_joi34.default.string().optional().allow("", null),
+        unit_of_measurement: import_joi34.default.string().valid("sqm").required(),
+        area: import_joi34.default.number().positive().required(),
+        status: import_joi34.default.string().optional().allow("", null)
+      }),
+      qty: import_joi34.default.number().integer().min(1).max(20).optional().default(1)
+    });
+    const { error } = validation.validate(data);
+    if (error) {
+      next(new import_nodejs_utils60.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const buildingUnit = await _add(data);
+      res.json({
+        message: "Building unit added successfully.",
+        data: { buildingUnit }
+      });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const data = req.body;
+    const id = req.params.id ?? "";
+    const validation = import_joi34.default.object({
+      id: import_joi34.default.string().hex().required(),
+      value: schemaUpdateOptions
+    });
+    const { error } = validation.validate({ id, value: data });
+    if (error) {
+      next(new import_nodejs_utils60.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const buildingUnit = await _updateById(id, data);
+      res.json({
+        message: "Building unit updated successfully.",
+        data: { buildingUnit }
+      });
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi34.default.object({
+      page: import_joi34.default.number().min(1).optional().allow("", null),
+      limit: import_joi34.default.number().min(1).optional().allow("", null),
+      search: import_joi34.default.string().optional().allow("", null),
+      school: import_joi34.default.string().hex().optional().allow("", null),
+      building: import_joi34.default.string().hex().optional().allow("", null),
+      status: import_joi34.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils60.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const status = req.query.status ?? "active";
+    const school = req.query.school ?? "";
+    const building = req.query.building ?? "";
+    const search = req.query.search ?? "";
+    try {
+      const buildings = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        status,
+        school,
+        search,
+        building
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi34.default.object({
+      id: import_joi34.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils60.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const buildingUnit = await _getById(id);
+      res.json({
+        message: "Successfully retrieved building unit.",
+        data: { buildingUnit }
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi34.default.object({
+      id: import_joi34.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils60.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/personnel/personnel.model.ts
+var import_nodejs_utils61 = require("@eeplatform/nodejs-utils");
+var import_joi35 = __toESM(require("joi"));
+var import_mongodb33 = require("mongodb");
+var schemaPersonnel = import_joi35.default.object({
+  _id: import_joi35.default.string().hex().optional().allow("", null),
+  school: import_joi35.default.string().hex().required(),
+  schoolName: import_joi35.default.string().optional().allow("", null),
+  firstName: import_joi35.default.string().required(),
+  lastName: import_joi35.default.string().required(),
+  middleName: import_joi35.default.string().optional().allow("", null),
+  suffix: import_joi35.default.string().optional().allow("", null),
+  title: import_joi35.default.string().optional().allow("", null),
+  classification: import_joi35.default.string().required(),
+  status: import_joi35.default.string().optional().allow("", null),
+  createdAt: import_joi35.default.date().optional().allow("", null),
+  updatedAt: import_joi35.default.date().optional().allow("", null),
+  deletedAt: import_joi35.default.date().optional().allow("", null)
+});
+function MPersonnel(value) {
+  const { error } = schemaPersonnel.validate(value);
+  if (error) {
+    import_nodejs_utils61.logger.info(`Personnel Model: ${error.message}`);
+    throw new import_nodejs_utils61.BadRequestError(error.message);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb33.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_nodejs_utils61.BadRequestError("Invalid _id format");
+    }
+  }
+  if (value.school && typeof value.school === "string") {
+    try {
+      value.school = new import_mongodb33.ObjectId(value.school);
+    } catch (error2) {
+      throw new import_nodejs_utils61.BadRequestError("Invalid school format");
+    }
+  }
+  if (!value.status) {
+    value.status = "active";
+  }
+  return {
+    _id: value._id,
+    school: value.school,
+    schoolName: value.schoolName ?? "",
+    firstName: value.firstName ?? "",
+    lastName: value.lastName ?? "",
+    middleName: value.middleName ?? "",
+    suffix: value.suffix ?? "",
+    title: value.title ?? "",
+    classification: value.classification ?? "",
+    status: value.status,
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/resources/personnel/personnel.repository.ts
+var import_nodejs_utils62 = require("@eeplatform/nodejs-utils");
+var import_mongodb34 = require("mongodb");
+function usePersonnelRepo() {
+  const db = import_nodejs_utils62.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "deped.school.personnel";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils62.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: {
+            firstName: 1,
+            lastName: 1,
+            classification: 1,
+            status: 1
+          },
+          name: "personnel_search_index"
+        },
+        { key: { status: 1 } },
+        { key: { classification: 1 } },
+        { key: { firstName: "text", lastName: "text", middleName: "text" } }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on personnel.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MPersonnel(value);
+      await collection.insertOne(value, { session });
+      delCachedData();
+      return "Successfully added personnel.";
+    } catch (error) {
+      import_nodejs_utils62.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils62.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to create personnel.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb34.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils62.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils62.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils62.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to update personnel.");
+      }
+    }
+  }
+  async function getAll({
+    school = "",
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status
+    };
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    if (search) {
+      query.$text = { $search: search };
+      cacheParams.search = search;
+    }
+    if (school) {
+      try {
+        query.school = new import_mongodb34.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils62.BadRequestError("Invalid school ID.");
+      }
+      cacheParams.school = school;
+    }
+    const cacheKey = (0, import_nodejs_utils62.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils62.logger.log({
+      level: "info",
+      message: `Cache key for getAll personnel: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils62.logger.log({
+          level: "info",
+          message: `Cache hit for getAll personnel: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils62.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils62.logger.log({
+          level: "info",
+          message: `Cache set for getAll personnel: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils62.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll personnel: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils62.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb34.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils62.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils62.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils62.logger.log({
+          level: "info",
+          message: `Cache hit for getById personnel: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils62.logger.log({
+          level: "info",
+          message: `Cache set for personnel by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils62.logger.log({
+          level: "error",
+          message: `Failed to set cache for personnel by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils62.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils62.InternalServerError("Failed to get personnel.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb34.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils62.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils62.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils62.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils62.InternalServerError("Failed to delete personnel.");
+      }
+    }
+  }
+  async function getByClassification(classification) {
+    const query = {
+      classification,
+      status: "active"
+    };
+    const cacheKey = (0, import_nodejs_utils62.makeCacheKey)(namespace_collection, { classification });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils62.logger.log({
+          level: "info",
+          message: `Cache hit for getByClassification personnel: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.find(query).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils62.logger.log({
+          level: "info",
+          message: `Cache set for personnel by classification: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils62.logger.log({
+          level: "error",
+          message: `Failed to set cache for personnel by classification: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils62.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils62.InternalServerError(
+          "Failed to get personnel by classification."
+        );
+      }
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils62.logger.log({
+        level: "info",
+        message: `Cache cleared for namespace: ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils62.logger.log({
+        level: "error",
+        message: `Failed to clear cache for namespace: ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  return {
+    createIndexes,
+    add,
+    updateById,
+    getAll,
+    getById,
+    deleteById,
+    getByClassification,
+    delCachedData
+  };
+}
+
+// src/resources/personnel/personnel.controller.ts
+var import_nodejs_utils63 = require("@eeplatform/nodejs-utils");
+var import_joi36 = __toESM(require("joi"));
+function usePersonnelController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    add: _add,
+    updateById: _updateById,
+    deleteById: _deleteById,
+    getByClassification: _getByClassification
+  } = usePersonnelRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaPersonnel.validate(value);
+    if (error) {
+      next(new import_nodejs_utils63.BadRequestError(error.message));
+      import_nodejs_utils63.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _add(value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const value = req.body;
+    const id = req.params.id ?? "";
+    const validation = import_joi36.default.object({
+      id: import_joi36.default.string().hex().required(),
+      value: import_joi36.default.object({
+        firstName: import_joi36.default.string().optional(),
+        lastName: import_joi36.default.string().optional(),
+        middleName: import_joi36.default.string().optional().allow("", null),
+        classification: import_joi36.default.string().optional(),
+        status: import_joi36.default.string().optional()
+      }).min(1)
+    });
+    const { error } = validation.validate({ id, value });
+    if (error) {
+      next(new import_nodejs_utils63.BadRequestError(error.message));
+      import_nodejs_utils63.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _updateById(id, value);
+      res.json(result);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi36.default.object({
+      page: import_joi36.default.number().min(1).optional().allow("", null),
+      limit: import_joi36.default.number().min(1).optional().allow("", null),
+      search: import_joi36.default.string().optional().allow("", null),
+      status: import_joi36.default.string().optional().allow("", null),
+      classification: import_joi36.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils63.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const status = req.query.status ?? "active";
+    const search = req.query.search ?? "";
+    try {
+      const personnel = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        status,
+        search
+      });
+      res.json(personnel);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAllBySchool(req, res, next) {
+    const school = req.params.school;
+    const schoolValidation = import_joi36.default.string().hex().required();
+    const { error: schoolError } = schoolValidation.validate(school);
+    if (schoolError) {
+      next(new import_nodejs_utils63.BadRequestError(schoolError.message));
+      return;
+    }
+    const query = req.query;
+    const validation = import_joi36.default.object({
+      page: import_joi36.default.number().min(1).optional().allow("", null),
+      limit: import_joi36.default.number().min(1).optional().allow("", null),
+      search: import_joi36.default.string().optional().allow("", null),
+      status: import_joi36.default.string().optional().allow("", null),
+      classification: import_joi36.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils63.BadRequestError(error.message));
+      return;
+    }
+    const page = parseInt(req.query.page) ?? 1;
+    let limit = parseInt(req.query.limit) ?? 20;
+    limit = isNaN(limit) ? 20 : limit;
+    const sort = req.query.sort ? String(req.query.sort).split(",") : "";
+    const sortOrder = req.query.sortOrder ? String(req.query.sortOrder).split(",") : "";
+    const sortObj = {};
+    if (sort && Array.isArray(sort) && sort.length && sortOrder && Array.isArray(sortOrder) && sortOrder.length) {
+      sort.forEach((field, index) => {
+        sortObj[field] = sortOrder[index] === "desc" ? -1 : 1;
+      });
+    }
+    const status = req.query.status ?? "active";
+    const search = req.query.search ?? "";
+    try {
+      const personnel = await _getAll({
+        school,
+        page,
+        limit,
+        sort: sortObj,
+        status,
+        search
+      });
+      res.json(personnel);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi36.default.object({
+      id: import_joi36.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils63.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const personnel = await _getById(id);
+      res.json({
+        message: "Successfully retrieved personnel.",
+        data: personnel
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi36.default.object({
+      id: import_joi36.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils63.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _deleteById(id);
+      res.json({
+        message: "Successfully deleted personnel.",
+        data: result
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByClassification(req, res, next) {
+    const classification = req.params.classification;
+    const validation = import_joi36.default.object({
+      classification: import_joi36.default.string().required()
+    });
+    const { error } = validation.validate({ classification });
+    if (error) {
+      next(new import_nodejs_utils63.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const personnel = await _getByClassification(classification);
+      res.json({
+        message: "Successfully retrieved personnel by classification.",
+        data: personnel
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    updateById,
+    getAll,
+    getAllBySchool,
+    getById,
+    deleteById,
+    getByClassification
+  };
+}
+
 // src/config.ts
 var dotenv = __toESM(require("dotenv"));
 dotenv.config();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MAsset,
+  MBuilding,
+  MBuildingUnit,
   MCurriculum,
   MCurriculumSubject,
   MGradeLevel,
   MLearner,
+  MPersonnel,
   MPlantilla,
   MStockCard,
   allowedSectionStudentStatuses,
@@ -38371,9 +40935,12 @@ dotenv.config();
   modelSection,
   modelSectionPreset,
   modelSectionStudent,
+  modelSectionSubject,
   schemaAsset,
   schemaAssetUpdateOption,
   schemaBasicEduCount,
+  schemaBuilding,
+  schemaBuildingUnit,
   schemaCurriculum,
   schemaCurriculumSubject,
   schemaCurriculumSubjectAdd,
@@ -38382,6 +40949,7 @@ dotenv.config();
   schemaEnrollment,
   schemaGenerateSections,
   schemaGradeLevel,
+  schemaPersonnel,
   schemaPlantilla,
   schemaRegion,
   schemaSchool,
@@ -38389,11 +40957,20 @@ dotenv.config();
   schemaSection,
   schemaSectionPreset,
   schemaSectionStudent,
+  schemaSectionSubject,
+  schemaSectionSubjectSetup,
   schemaStockCard,
+  schemaUpdateOptions,
   schemaUpdateStatus,
   useAssetController,
   useAssetRepo,
   useBasicEduCountRepo,
+  useBuildingController,
+  useBuildingRepo,
+  useBuildingService,
+  useBuildingUnitController,
+  useBuildingUnitRepo,
+  useBuildingUnitService,
   useCurriculumController,
   useCurriculumRepo,
   useCurriculumSubjectController,
@@ -38409,6 +40986,8 @@ dotenv.config();
   useGradeLevelRepo,
   useLearnerController,
   useLearnerRepo,
+  usePersonnelController,
+  usePersonnelRepo,
   usePlantillaController,
   usePlantillaRepo,
   usePlantillaService,
@@ -38422,6 +41001,9 @@ dotenv.config();
   useSectionPresetRepo,
   useSectionRepo,
   useSectionStudentRepo,
+  useSectionSubjectController,
+  useSectionSubjectRepo,
+  useSectionSubjectService,
   useStockCardController,
   useStockCardRepository,
   useStockCardService