@eeplatform/core 1.4.5 → 1.5.1

package/dist/index.js

@@ -10384,7 +10384,7 @@ var require_ms = __commonJS({
       options = options || {};
       var type = typeof val;
       if (type === "string" && val.length > 0) {
-        return parse3(val);
+        return parse4(val);
       } else if (type === "number" && isNaN(val) === false) {
         return options.long ? fmtLong(val) : fmtShort(val);
       }
@@ -10392,7 +10392,7 @@ var require_ms = __commonJS({
         "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
       );
     };
-    function parse3(str) {
+    function parse4(str) {
       str = String(str);
       if (str.length > 100) {
         return;
@@ -11345,12 +11345,15 @@ __export(src_exports, {
   MAsset: () => MAsset,
   MBuilding: () => MBuilding,
   MBuildingUnit: () => MBuildingUnit,
+  MCurriculum: () => MCurriculum,
   MDivision: () => MDivision,
   MEntity: () => MEntity,
   MFile: () => MFile,
+  MGradeLevel: () => MGradeLevel,
   MMember: () => MMember,
   MONGO_DB: () => MONGO_DB,
   MONGO_URI: () => MONGO_URI,
+  MOffice: () => MOffice,
   MOrder: () => MOrder,
   MOrg: () => MOrg,
   MPaymentMethod: () => MPaymentMethod,
@@ -11391,7 +11394,10 @@ __export(src_exports, {
   schemaAssetUpdateOption: () => schemaAssetUpdateOption,
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
+  schemaCurriculum: () => schemaCurriculum,
   schemaDivision: () => schemaDivision,
+  schemaGradeLevel: () => schemaGradeLevel,
+  schemaOffice: () => schemaOffice,
   schemaPlantilla: () => schemaPlantilla,
   schemaRegion: () => schemaRegion,
   schemaSchool: () => schemaSchool,
@@ -11409,6 +11415,8 @@ __export(src_exports, {
   useBuildingUnitRepo: () => useBuildingUnitRepo,
   useCounterModel: () => useCounterModel,
   useCounterRepo: () => useCounterRepo,
+  useCurriculumController: () => useCurriculumController,
+  useCurriculumRepo: () => useCurriculumRepo,
   useDivisionController: () => useDivisionController,
   useDivisionRepo: () => useDivisionRepo,
   useDivisionService: () => useDivisionService,
@@ -11418,12 +11426,17 @@ __export(src_exports, {
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
   useGitHubService: () => useGitHubService,
+  useGradeLevelController: () => useGradeLevelController,
+  useGradeLevelRepo: () => useGradeLevelRepo,
   useInvoiceController: () => useInvoiceController,
   useInvoiceModel: () => useInvoiceModel,
   useInvoiceRepo: () => useInvoiceRepo,
   useInvoiceService: () => useInvoiceService,
   useMemberController: () => useMemberController,
   useMemberRepo: () => useMemberRepo,
+  useOfficeController: () => useOfficeController,
+  useOfficeRepo: () => useOfficeRepo,
+  useOfficeService: () => useOfficeService,
   useOrderController: () => useOrderController,
   useOrderRepo: () => useOrderRepo,
   useOrgController: () => useOrgController,
@@ -28328,7 +28341,10 @@ function useBuildingUnitService() {
     try {
       await session.startTransaction();
       for (let index = 0; index < value.qty; index++) {
-        await _add({ ...value.building }, session);
+        await _add(
+          { ...value.building, name: `${value.building.name} ${index + 1}` },
+          session
+        );
       }
       await session.commitTransaction();
       return "Building unit added successfully.";
@@ -29820,6 +29836,10 @@ var import_joi41 = __toESM(require("joi"));
 var import_mongodb46 = require("mongodb");
 var schemaPlantilla = import_joi41.default.object({
   _id: import_joi41.default.string().hex().optional().allow(null, ""),
+  org: import_joi41.default.string().hex().required(),
+  orgUnitCode: import_joi41.default.string().optional().allow(null, ""),
+  employmentType: import_joi41.default.string().optional().allow(null, ""),
+  personnelType: import_joi41.default.string().required(),
   itemNumber: import_joi41.default.string().required(),
   positionTitle: import_joi41.default.string().required(),
   positionCategory: import_joi41.default.string().required(),
@@ -29828,8 +29848,7 @@ var schemaPlantilla = import_joi41.default.object({
   division: import_joi41.default.string().hex().optional().allow(null, ""),
   divisionName: import_joi41.default.string().optional().allow(null, ""),
   salaryGrade: import_joi41.default.number().required(),
-  step: import_joi41.default.number().optional().allow(null, 0),
-  incumbent: import_joi41.default.string().optional().allow(null, ""),
+  employeeName: import_joi41.default.string().optional().allow(null, ""),
   annualSalary: import_joi41.default.number().optional().allow(null, 0),
   monthlySalary: import_joi41.default.number().optional().allow(null, 0),
   status: import_joi41.default.string().required(),
@@ -29857,14 +29876,18 @@ function MPlantilla(data) {
     positionCategory: data.positionCategory ?? "",
     status: data.status ?? "active",
     salaryGrade: data.salaryGrade ?? 0,
-    step: data.step ?? 0,
     monthlySalary: data.monthlySalary ?? 0,
     annualSalary: data.annualSalary ?? 0,
     region: data.region ?? "",
     regionName: data.regionName ?? "",
     division: data.division ?? "",
     divisionName: data.divisionName ?? "",
-    incumbent: data.incumbent ?? "",
+    org: data.org ?? "",
+    orgUnitCode: data.orgUnitCode ?? "",
+    employmentType: data.employmentType ?? "",
+    personnelType: data.personnelType ?? "",
+    employee: data.employee ?? "",
+    employeeName: data.employeeName ?? "",
     createdAt: data.createdAt ? new Date(data.createdAt) : /* @__PURE__ */ new Date(),
     updatedAt: data.updatedAt ? new Date(data.updatedAt) : "",
     deletedAt: data.deletedAt ? new Date(data.deletedAt) : ""
@@ -30205,7 +30228,8 @@ function usePlantillaService() {
             salaryGrade: parseInt(
               plantillaData.salarygrade || plantillaData.salary_grade || "1"
             ) || 1,
-            step: parseInt(plantillaData.step || "1") || 1,
+            org: "",
+            personnelType: "",
             status: status.trim() || "active"
           };
           if (region)
@@ -30218,9 +30242,6 @@ function usePlantillaService() {
           if (plantillaData.divisionname || plantillaData.division_name) {
             plantilla.divisionName = plantillaData.divisionname || plantillaData.division_name;
           }
-          if (plantillaData.incumbent) {
-            plantilla.incumbent = plantillaData.incumbent;
-          }
           if (plantillaData.employee) {
             plantilla.employee = plantillaData.employee;
           }
@@ -30501,6 +30522,1731 @@ function usePlantillaController() {
     bulkAddPlantillas
   };
 }
+
+// src/models/office.model.ts
+var import_nodejs_utils86 = require("@eeplatform/nodejs-utils");
+var import_joi43 = __toESM(require("joi"));
+var import_mongodb48 = require("mongodb");
+var schemaOffice = import_joi43.default.object({
+  _id: import_joi43.default.string().hex().optional().allow(null, ""),
+  name: import_joi43.default.string().required(),
+  code: import_joi43.default.string().required(),
+  type: import_joi43.default.string().required(),
+  parent: import_joi43.default.string().hex().optional().allow(null, ""),
+  path: import_joi43.default.string().required(),
+  status: import_joi43.default.string().required(),
+  createdAt: import_joi43.default.date().iso().optional().allow(null, ""),
+  updatedAt: import_joi43.default.date().iso().optional().allow(null, ""),
+  deletedAt: import_joi43.default.date().iso().optional().allow(null, "")
+});
+function MOffice(data) {
+  const { error } = schemaOffice.validate(data);
+  if (error) {
+    throw new import_nodejs_utils86.BadRequestError(error.message);
+  }
+  if (data._id && typeof data._id === "string") {
+    try {
+      data._id = new import_mongodb48.ObjectId(data._id);
+    } catch (error2) {
+      throw new import_nodejs_utils86.BadRequestError("Invalid _id.");
+    }
+  }
+  if (data.parent && typeof data.parent === "string") {
+    try {
+      data.parent = new import_mongodb48.ObjectId(data.parent);
+    } catch (error2) {
+      throw new import_nodejs_utils86.BadRequestError("Invalid parent.");
+    }
+  }
+  return {
+    _id: data._id,
+    name: data.name ?? "",
+    code: data.code ?? "",
+    type: data.type ?? "",
+    parent: data.parent ?? "",
+    path: data.path ?? "",
+    status: data.status ?? "active",
+    createdAt: data.createdAt ? new Date(data.createdAt) : /* @__PURE__ */ new Date(),
+    updatedAt: data.updatedAt ? new Date(data.updatedAt) : "",
+    deletedAt: data.deletedAt ? new Date(data.deletedAt) : ""
+  };
+}
+
+// src/repositories/office.repository.ts
+var import_nodejs_utils87 = require("@eeplatform/nodejs-utils");
+var import_mongodb49 = require("mongodb");
+function useOfficeRepo() {
+  const db = import_nodejs_utils87.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "offices";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils87.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: { name: 1, code: 1 },
+          unique: true,
+          name: "unique_name_code_index"
+        },
+        { key: { type: 1 } },
+        { key: { parent: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on offices.");
+    }
+  }
+  async function add(value, session, clearCache = true) {
+    try {
+      value = MOffice(value);
+      const res = await collection.insertOne(value, { session });
+      if (clearCache) {
+        delCachedData();
+      }
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils87.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils87.BadRequestError("Office already exists.");
+        }
+        throw new Error("Failed to create office.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb49.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils87.BadRequestError("Invalid ID.");
+    }
+    value.updatedAt = /* @__PURE__ */ new Date();
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: value },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils87.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to update office.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    type = "",
+    parent = "",
+    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 (type) {
+      query.type = type;
+    }
+    if (parent) {
+      try {
+        query.parent = new import_mongodb49.ObjectId(parent);
+      } catch (error) {
+        throw new import_nodejs_utils87.BadRequestError("Invalid parent ID.");
+      }
+    }
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search)
+      cacheParams.search = search;
+    if (type)
+      cacheParams.type = type;
+    if (parent)
+      cacheParams.parent = parent;
+    if (status !== "active")
+      cacheParams.status = status;
+    const cacheKey = (0, import_nodejs_utils87.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils87.logger.log({
+      level: "info",
+      message: `Cache key for getAll offices: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache hit for getAll offices: ${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_utils87.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache set for getAll offices: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils87.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll offices: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils87.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb49.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils87.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils87.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache hit for getById office: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache set for office by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils87.logger.log({
+          level: "error",
+          message: `Failed to set cache for office by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils87.InternalServerError("Failed to get office.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb49.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils87.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils87.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils87.InternalServerError("Failed to delete office.");
+      }
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils87.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils87.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    delCachedData
+  };
+}
+
+// src/services/office.service.ts
+var import_nodejs_utils88 = require("@eeplatform/nodejs-utils");
+var XLSX3 = __toESM(require("xlsx"));
+var Papa3 = __toESM(require("papaparse"));
+function useOfficeService() {
+  const { add: addOffice, delCachedData } = useOfficeRepo();
+  async function addBulk(file) {
+    import_nodejs_utils88.logger.log({
+      level: "info",
+      message: `Starting office bulk upload. File: ${file.originalname}, Size: ${file.size} bytes`
+    });
+    const MAX_SIZE = 16 * 1024 * 1024;
+    let offices = [];
+    let totalSize = 0;
+    let validatedOffices = [];
+    if (!file.buffer) {
+      throw new import_nodejs_utils88.BadRequestError("File buffer is empty or corrupted");
+    }
+    try {
+      const fileExtension = file.originalname.split(".").pop()?.toLowerCase();
+      if (fileExtension === "csv") {
+        const csvData = file.buffer.toString("utf-8");
+        totalSize = Buffer.byteLength(csvData, "utf8");
+        if (totalSize > MAX_SIZE) {
+          throw new import_nodejs_utils88.BadRequestError(
+            `File size exceeds limit. Maximum allowed: ${MAX_SIZE / 1024 / 1024}MB, Received: ${(totalSize / 1024 / 1024).toFixed(2)}MB`
+          );
+        }
+        const parseResult = Papa3.parse(csvData, {
+          header: true,
+          skipEmptyLines: true,
+          transformHeader: (header) => {
+            return header.toLowerCase().replace(/\s+/g, "").replace(/[^\w]/g, "");
+          }
+        });
+        if (parseResult.errors.length > 0) {
+          throw new import_nodejs_utils88.BadRequestError(
+            `CSV parsing errors: ${parseResult.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        offices = parseResult.data || [];
+      } else if (["xlsx", "xls"].includes(fileExtension || "")) {
+        totalSize = file.buffer.length;
+        if (totalSize > MAX_SIZE) {
+          throw new import_nodejs_utils88.BadRequestError(
+            `File size exceeds limit. Maximum allowed: ${MAX_SIZE / 1024 / 1024}MB, Received: ${(totalSize / 1024 / 1024).toFixed(2)}MB`
+          );
+        }
+        const workbook = XLSX3.read(file.buffer, { type: "buffer" });
+        const sheetName = workbook.SheetNames[0];
+        if (!sheetName) {
+          throw new import_nodejs_utils88.BadRequestError("Excel file contains no sheets");
+        }
+        const worksheet = workbook.Sheets[sheetName];
+        offices = XLSX3.utils.sheet_to_json(worksheet, {
+          header: 1,
+          defval: ""
+        });
+        if (offices.length > 0) {
+          const headers = offices[0];
+          offices = offices.slice(1).map((row) => {
+            const obj = {};
+            headers.forEach((header, index) => {
+              obj[header.trim()] = row[index] || "";
+            });
+            return obj;
+          });
+        }
+      } else {
+        throw new import_nodejs_utils88.BadRequestError(
+          "Unsupported file format. Please upload CSV, XLS, or XLSX files."
+        );
+      }
+      if (!offices || offices.length === 0) {
+        throw new import_nodejs_utils88.BadRequestError("File is empty or contains no valid data");
+      }
+      const results = {
+        total: offices.length,
+        successful: 0,
+        failed: 0,
+        errors: []
+      };
+      import_nodejs_utils88.logger.log({
+        level: "info",
+        message: `Processing ${offices.length} offices from file`
+      });
+      for (let i = 0; i < offices.length; i++) {
+        const officeData = offices[i];
+        try {
+          const cleanOffice = {
+            name: String(officeData.name || "").trim(),
+            code: String(officeData.code || "").trim(),
+            type: String(officeData.type || "").trim(),
+            path: String(officeData.path || "").trim(),
+            status: String(officeData.status || "active").trim()
+          };
+          if (officeData.parent && String(officeData.parent).trim()) {
+            cleanOffice.parent = String(officeData.parent).trim();
+          }
+          const { error } = schemaOffice.validate(cleanOffice);
+          if (error) {
+            results.errors.push(`Row ${i + 1}: ${error.message}`);
+            results.failed++;
+            continue;
+          }
+          validatedOffices.push(cleanOffice);
+        } catch (error) {
+          results.errors.push(`Row ${i + 1}: ${error.message}`);
+          results.failed++;
+        }
+      }
+      if (validatedOffices.length === 0) {
+        throw new import_nodejs_utils88.BadRequestError(
+          "No valid offices found in file. Please check the format and data."
+        );
+      }
+      const db = import_nodejs_utils88.useAtlas.getDb();
+      if (!db) {
+        throw new Error("Database connection not available");
+      }
+      const session = db.client.startSession();
+      try {
+        await session.withTransaction(async () => {
+          const batchSize = 100;
+          for (let i = 0; i < validatedOffices.length; i += batchSize) {
+            const batch = validatedOffices.slice(i, i + batchSize);
+            for (const office of batch) {
+              try {
+                await addOffice(office, session, false);
+                results.successful++;
+              } catch (error) {
+                results.failed++;
+                results.errors.push(
+                  `Failed to insert office "${office.name}": ${error.message}`
+                );
+                import_nodejs_utils88.logger.log({
+                  level: "error",
+                  message: `Failed to insert office: ${error.message}`
+                });
+              }
+            }
+          }
+        });
+        delCachedData();
+        import_nodejs_utils88.logger.log({
+          level: "info",
+          message: `Bulk upload completed. Successful: ${results.successful}, Failed: ${results.failed}`
+        });
+        return results;
+      } catch (error) {
+        import_nodejs_utils88.logger.log({
+          level: "error",
+          message: `Transaction failed: ${error.message}`
+        });
+        throw new import_nodejs_utils88.BadRequestError(`Bulk upload failed: ${error.message}`);
+      } finally {
+        await session.endSession();
+      }
+    } catch (error) {
+      import_nodejs_utils88.logger.log({
+        level: "error",
+        message: `Bulk office upload failed: ${error.message}`
+      });
+      if (error instanceof import_nodejs_utils88.BadRequestError) {
+        throw error;
+      }
+      throw new import_nodejs_utils88.BadRequestError(`File processing failed: ${error.message}`);
+    }
+  }
+  return {
+    addBulk
+  };
+}
+
+// src/controllers/office.controller.ts
+var import_nodejs_utils89 = require("@eeplatform/nodejs-utils");
+var import_joi44 = __toESM(require("joi"));
+function useOfficeController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    updateById: _updateByIdById,
+    deleteById: _deleteByIdById
+  } = useOfficeRepo();
+  const { addBulk: _addBulk } = useOfficeService();
+  async function add(req, res, next) {
+    const value = req.body;
+    const validation = import_joi44.default.object({
+      name: import_joi44.default.string().required(),
+      code: import_joi44.default.string().required(),
+      type: import_joi44.default.string().required(),
+      path: import_joi44.default.string().required(),
+      parent: import_joi44.default.string().hex().optional().allow(null, ""),
+      status: import_joi44.default.string().optional().allow(null, "")
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_nodejs_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _add(value);
+      res.json({ message: "Office created successfully", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    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 type = req.query.type ?? "";
+    const parent = req.query.parent ?? "";
+    const status = req.query.status ?? "active";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils89.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils89.BadRequestError("Invalid limit number."));
+      return;
+    }
+    const validation = import_joi44.default.object({
+      page: import_joi44.default.number().min(1).optional().allow("", null),
+      limit: import_joi44.default.number().min(1).optional().allow("", null),
+      search: import_joi44.default.string().optional().allow("", null),
+      type: import_joi44.default.string().optional().allow("", null),
+      parent: import_joi44.default.string().optional().allow("", null),
+      status: import_joi44.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({
+      page,
+      limit,
+      search,
+      type,
+      parent,
+      status
+    });
+    if (error) {
+      next(new import_nodejs_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const offices = await _getAll({
+        search,
+        page,
+        limit,
+        type,
+        parent,
+        status
+      });
+      res.json(offices);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi44.default.object({
+      id: import_joi44.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const office = await _getById(id);
+      if (!office) {
+        next(new import_nodejs_utils89.BadRequestError("Office not found."));
+        return;
+      }
+      res.json(office);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const id = req.params.id;
+    const value = req.body;
+    const validation = import_joi44.default.object({
+      id: import_joi44.default.string().hex().required(),
+      name: import_joi44.default.string().optional(),
+      code: import_joi44.default.string().optional(),
+      type: import_joi44.default.string().optional(),
+      parent: import_joi44.default.string().hex().optional().allow(null, ""),
+      path: import_joi44.default.string().optional(),
+      status: import_joi44.default.string().optional()
+    });
+    const { error } = validation.validate({ id, ...value });
+    if (error) {
+      next(new import_nodejs_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _updateByIdById(id, value);
+      if (result.matchedCount === 0) {
+        next(new import_nodejs_utils89.BadRequestError("Office not found."));
+        return;
+      }
+      res.json({ message: "Office updated successfully" });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi44.default.object({
+      id: import_joi44.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils89.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _deleteByIdById(id);
+      if (result.matchedCount === 0) {
+        next(new import_nodejs_utils89.BadRequestError("Office not found."));
+        return;
+      }
+      res.json({ message: "Office deleted successfully" });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function bulkAddOffices(req, res, next) {
+    if (!req.file) {
+      res.status(400).send("File is required!");
+      return;
+    }
+    try {
+      const result = await _addBulk(req.file);
+      res.status(201).json(result);
+      return;
+    } catch (error) {
+      next(error);
+      return;
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    bulkAddOffices
+  };
+}
+
+// src/models/curriculum.model.ts
+var import_nodejs_utils90 = require("@eeplatform/nodejs-utils");
+var import_joi45 = __toESM(require("joi"));
+var import_mongodb50 = require("mongodb");
+var schemaCurriculum = import_joi45.default.object({
+  _id: import_joi45.default.string().hex().optional(),
+  school: import_joi45.default.string().hex().required(),
+  code: import_joi45.default.string().required(),
+  effectiveSchoolYear: import_joi45.default.string().required(),
+  maxTeachingHoursPerDay: import_joi45.default.number().integer().min(1).required(),
+  subjects: import_joi45.default.array().items(
+    import_joi45.default.object({
+      educationLevel: import_joi45.default.string().required(),
+      gradeLevel: import_joi45.default.string().required(),
+      subjectCode: import_joi45.default.string().required(),
+      subjectName: import_joi45.default.string().required(),
+      subjectType: import_joi45.default.string().required(),
+      sessionFrequency: import_joi45.default.number().integer().min(0).required(),
+      sessionDuration: import_joi45.default.number().integer().min(0).required(),
+      totalMinutesPerWeek: import_joi45.default.number().integer().min(0).required()
+    })
+  ),
+  curriculumMemoRef: import_joi45.default.string().optional().allow("", null),
+  status: import_joi45.default.string().optional().allow("", null),
+  createdAt: import_joi45.default.date().optional().allow("", null),
+  updatedAt: import_joi45.default.date().optional().allow("", null),
+  deletedAt: import_joi45.default.date().optional().allow("", null),
+  createdBy: import_joi45.default.string().optional().allow("", null),
+  updatedBy: import_joi45.default.string().optional().allow("", null),
+  deletedBy: import_joi45.default.string().optional().allow("", null)
+});
+function MCurriculum(value) {
+  const { error } = schemaCurriculum.validate(value);
+  if (error) {
+    import_nodejs_utils90.logger.info(`Curriculum Model: ${error.message}`);
+    throw new import_nodejs_utils90.BadRequestError(error.message);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb50.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_nodejs_utils90.BadRequestError("Invalid _id format");
+    }
+  }
+  return {
+    _id: value._id ?? void 0,
+    school: value.school ?? "",
+    code: value.code ?? "",
+    effectiveSchoolYear: value.effectiveSchoolYear ?? "",
+    maxTeachingHoursPerDay: value.maxTeachingHoursPerDay ?? 0,
+    subjects: value.subjects ?? [],
+    curriculumMemoRef: value.curriculumMemoRef ?? "",
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? "",
+    createdBy: value.createdBy ?? "",
+    updatedBy: value.updatedBy ?? "",
+    deletedBy: value.deletedBy ?? ""
+  };
+}
+
+// src/repositories/curriculum.repository.ts
+var import_nodejs_utils91 = require("@eeplatform/nodejs-utils");
+var import_mongodb51 = require("mongodb");
+function useCurriculumRepo() {
+  const db = import_nodejs_utils91.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "school.curriculums";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils91.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        {
+          key: {
+            school: 1,
+            code: 1,
+            status: 1
+          },
+          unique: true,
+          partialFilterExpression: { status: "active" },
+          name: "unique_code_index"
+        },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on curriculums.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MCurriculum(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils91.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils91.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils91.BadRequestError("Curriculum already exists.");
+        }
+        throw new Error("Failed to create curriculum.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb51.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils91.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils91.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils91.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to update curriculum.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    if (search) {
+      query.$or = [
+        { code: { $regex: search, $options: "i" } },
+        { subjectName: { $regex: search, $options: "i" } },
+        { subjectCode: { $regex: search, $options: "i" } }
+      ];
+    }
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search)
+      cacheParams.search = search;
+    if (status !== "active")
+      cacheParams.status = status;
+    const cacheKey = (0, import_nodejs_utils91.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils91.logger.log({
+      level: "info",
+      message: `Cache key for getAll curriculums: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils91.logger.log({
+          level: "info",
+          message: `Cache hit for getAll curriculums: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit },
+        {
+          $project: {
+            _id: 1,
+            school: 1,
+            code: 1,
+            effectiveSchoolYear: 1,
+            maxTeachingHoursPerDay: 1,
+            curriculumMemoRef: 1,
+            status: 1,
+            createdAt: 1,
+            updatedAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils91.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils91.logger.log({
+          level: "info",
+          message: `Cache set for getAll curriculums: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils91.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll curriculums: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils91.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb51.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils91.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils91.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils91.logger.log({
+          level: "info",
+          message: `Cache hit for getById curriculum: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils91.logger.log({
+          level: "info",
+          message: `Cache set for curriculum by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils91.logger.log({
+          level: "error",
+          message: `Failed to set cache for curriculum by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils91.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils91.InternalServerError("Failed to get curriculum.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb51.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils91.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils91.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils91.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils91.InternalServerError("Failed to delete curriculum.");
+      }
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils91.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils91.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/controllers/curriculum.controller.ts
+var import_nodejs_utils92 = require("@eeplatform/nodejs-utils");
+var import_joi46 = __toESM(require("joi"));
+function useCurriculumController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    add: _add,
+    updateById: _updateById,
+    deleteById: _deleteById
+  } = useCurriculumRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaCurriculum.validate(value);
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      import_nodejs_utils92.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_joi46.default.object({
+      id: import_joi46.default.string().hex().required(),
+      value: import_joi46.default.object({
+        code: import_joi46.default.string().optional(),
+        educationLevel: import_joi46.default.string().optional(),
+        gradeLevel: import_joi46.default.string().optional(),
+        subjectCode: import_joi46.default.string().optional(),
+        subjectName: import_joi46.default.string().optional(),
+        subjectType: import_joi46.default.string().optional(),
+        sessionFrequency: import_joi46.default.number().integer().min(0).optional(),
+        sessionDuration: import_joi46.default.number().integer().min(0).optional(),
+        totalMinutesPerWeek: import_joi46.default.number().integer().min(0).optional(),
+        curriculumMemoRef: import_joi46.default.string().optional().allow("", null)
+      }).min(1)
+    });
+    const { error } = validation.validate({ id, value });
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      import_nodejs_utils92.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_joi46.default.object({
+      page: import_joi46.default.number().min(1).optional().allow("", null),
+      limit: import_joi46.default.number().min(1).optional().allow("", null),
+      search: import_joi46.default.string().optional().allow("", null),
+      status: import_joi46.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils92.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 curriculums = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        status,
+        search
+      });
+      res.json(curriculums);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi46.default.object({
+      id: import_joi46.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const curriculum = await _getById(id);
+      res.json({
+        message: "Successfully retrieved curriculum.",
+        data: { curriculum }
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi46.default.object({
+      id: import_joi46.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _deleteById(id);
+      res.json({
+        message: "Successfully deleted curriculum.",
+        data: result
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/models/grade-level.model.ts
+var import_nodejs_utils93 = require("@eeplatform/nodejs-utils");
+var import_joi47 = __toESM(require("joi"));
+var import_mongodb52 = require("mongodb");
+var schemaGradeLevel = import_joi47.default.object({
+  _id: import_joi47.default.string().hex().optional(),
+  school: import_joi47.default.string().hex().optional(),
+  educationLevel: import_joi47.default.string().required(),
+  gradeLevel: import_joi47.default.string().required(),
+  teachingStyle: import_joi47.default.string().required(),
+  defaultStartTime: import_joi47.default.string().optional().allow("", null),
+  defaultEndTime: import_joi47.default.string().optional().allow("", null),
+  status: import_joi47.default.string().optional().allow("", null),
+  createdAt: import_joi47.default.date().optional().allow("", null),
+  updatedAt: import_joi47.default.date().optional().allow("", null),
+  deletedAt: import_joi47.default.date().optional().allow("", null),
+  createdBy: import_joi47.default.string().optional().allow("", null),
+  updatedBy: import_joi47.default.string().optional().allow("", null),
+  deletedBy: import_joi47.default.string().optional().allow("", null)
+});
+function MGradeLevel(value) {
+  const { error } = schemaGradeLevel.validate(value);
+  if (error) {
+    import_nodejs_utils93.logger.info(`Grade Level Model: ${error.message}`);
+    throw new import_nodejs_utils93.BadRequestError(error.message);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb52.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_nodejs_utils93.BadRequestError("Invalid _id format");
+    }
+  }
+  if (value.school && typeof value.school === "string") {
+    try {
+      value.school = new import_mongodb52.ObjectId(value.school);
+    } catch (error2) {
+      throw new import_nodejs_utils93.BadRequestError("Invalid school format");
+    }
+  }
+  return {
+    _id: value._id ?? void 0,
+    school: value.school ?? void 0,
+    educationLevel: value.educationLevel ?? "",
+    gradeLevel: value.gradeLevel ?? "",
+    teachingStyle: value.teachingStyle ?? "",
+    defaultStartTime: value.defaultStartTime ?? "",
+    defaultEndTime: value.defaultEndTime ?? "",
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? "",
+    createdBy: value.createdBy ?? "",
+    updatedBy: value.updatedBy ?? "",
+    deletedBy: value.deletedBy ?? ""
+  };
+}
+
+// src/repositories/grade-level.repository.ts
+var import_nodejs_utils94 = require("@eeplatform/nodejs-utils");
+var import_mongodb53 = require("mongodb");
+function useGradeLevelRepo() {
+  const db = import_nodejs_utils94.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "school.grade-levels";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils94.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { educationLevel: 1 } },
+        { key: { gradeLevel: 1 } },
+        { key: { teachingStyle: 1 } },
+        { key: { school: 1 } },
+        { key: { status: 1 } },
+        {
+          key: { educationLevel: 1, gradeLevel: 1, school: 1 },
+          unique: true,
+          partialFilterExpression: { status: { $in: ["active", "suspended"] } },
+          name: "unique_grade_level_per_school_index"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on grade levels.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MGradeLevel(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils94.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils94.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils94.BadRequestError(
+            "Grade level already exists for this education level and school."
+          );
+        }
+        throw new Error("Failed to create grade level.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb53.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils94.BadRequestError("Invalid ID.");
+    }
+    if (value.school && typeof value.school === "string") {
+      try {
+        value.school = new import_mongodb53.ObjectId(value.school);
+      } catch (error) {
+        throw new import_nodejs_utils94.BadRequestError("Invalid school ID format.");
+      }
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { ...value, updatedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils94.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils94.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils94.BadRequestError(
+            "Grade level already exists for this education level and school."
+          );
+        }
+        throw new Error("Failed to update grade level.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    educationLevel = "",
+    gradeLevel = "",
+    teachingStyle = "",
+    school = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: -1 };
+    if (search) {
+      query.$or = [
+        { educationLevel: { $regex: search, $options: "i" } },
+        { gradeLevel: { $regex: search, $options: "i" } },
+        { teachingStyle: { $regex: search, $options: "i" } }
+      ];
+    }
+    if (educationLevel) {
+      query.educationLevel = educationLevel;
+    }
+    if (gradeLevel) {
+      query.gradeLevel = gradeLevel;
+    }
+    if (teachingStyle) {
+      query.teachingStyle = teachingStyle;
+    }
+    if (school) {
+      try {
+        query.school = new import_mongodb53.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils94.BadRequestError("Invalid school ID format.");
+      }
+    }
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search)
+      cacheParams.search = search;
+    if (educationLevel)
+      cacheParams.educationLevel = educationLevel;
+    if (gradeLevel)
+      cacheParams.gradeLevel = gradeLevel;
+    if (teachingStyle)
+      cacheParams.teachingStyle = teachingStyle;
+    if (school)
+      cacheParams.school = school;
+    if (status !== "active")
+      cacheParams.status = status;
+    const cacheKey = (0, import_nodejs_utils94.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils94.logger.log({
+      level: "info",
+      message: `Cache key for getAll grade levels: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils94.logger.log({
+          level: "info",
+          message: `Cache hit for getAll grade levels: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit },
+        {
+          $lookup: {
+            from: "school.schools",
+            localField: "school",
+            foreignField: "_id",
+            as: "schoolDetails"
+          }
+        },
+        {
+          $addFields: {
+            schoolName: { $arrayElemAt: ["$schoolDetails.name", 0] }
+          }
+        },
+        {
+          $project: {
+            schoolDetails: 0
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_nodejs_utils94.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils94.logger.log({
+          level: "info",
+          message: `Cache set for getAll grade levels: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils94.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll grade levels: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils94.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb53.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils94.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils94.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils94.logger.log({
+          level: "info",
+          message: `Cache hit for getById grade level: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.aggregate([
+        { $match: { _id } },
+        {
+          $lookup: {
+            from: "school.schools",
+            localField: "school",
+            foreignField: "_id",
+            as: "schoolDetails"
+          }
+        },
+        {
+          $addFields: {
+            schoolName: { $arrayElemAt: ["$schoolDetails.name", 0] }
+          }
+        },
+        {
+          $project: {
+            schoolDetails: 0
+          }
+        }
+      ]).toArray();
+      const gradeLevel = result[0] || null;
+      setCache(cacheKey, gradeLevel, 300).then(() => {
+        import_nodejs_utils94.logger.log({
+          level: "info",
+          message: `Cache set for grade level by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils94.logger.log({
+          level: "error",
+          message: `Failed to set cache for grade level by id: ${err.message}`
+        });
+      });
+      return gradeLevel;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils94.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils94.InternalServerError("Failed to get grade level.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb53.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils94.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils94.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils94.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils94.InternalServerError("Failed to delete grade level.");
+      }
+    }
+  }
+  async function getByEducationLevel(educationLevel, school) {
+    const query = {
+      educationLevel,
+      status: "active"
+    };
+    if (school) {
+      try {
+        query.school = new import_mongodb53.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils94.BadRequestError("Invalid school ID format.");
+      }
+    }
+    const cacheKey = (0, import_nodejs_utils94.makeCacheKey)(namespace_collection, {
+      educationLevel,
+      school: school || "all",
+      method: "getByEducationLevel"
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils94.logger.log({
+          level: "info",
+          message: `Cache hit for getByEducationLevel: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.find(query).sort({ gradeLevel: 1 }).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils94.logger.log({
+          level: "info",
+          message: `Cache set for getByEducationLevel: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils94.logger.log({
+          level: "error",
+          message: `Failed to set cache for getByEducationLevel: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      import_nodejs_utils94.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils94.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils94.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    getByEducationLevel
+  };
+}
+
+// src/controllers/grade-level.controller.ts
+var import_nodejs_utils95 = require("@eeplatform/nodejs-utils");
+var import_joi48 = __toESM(require("joi"));
+function useGradeLevelController() {
+  const {
+    getAll: _getAll,
+    getById: _getById,
+    add: _add,
+    updateById: _updateById,
+    deleteById: _deleteById,
+    getByEducationLevel: _getByEducationLevel
+  } = useGradeLevelRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const validation = import_joi48.default.object({
+      school: import_joi48.default.string().hex().optional(),
+      educationLevel: import_joi48.default.string().required(),
+      gradeLevel: import_joi48.default.string().required(),
+      teachingStyle: import_joi48.default.string().required(),
+      defaultStartTime: import_joi48.default.string().optional().allow("", null),
+      defaultEndTime: import_joi48.default.string().optional().allow("", null),
+      status: import_joi48.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_nodejs_utils95.BadRequestError(error.message));
+      import_nodejs_utils95.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _add(value);
+      res.json({
+        message: "Successfully created grade level.",
+        data: { _id: result }
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const value = req.body;
+    const id = req.params.id ?? "";
+    const validation = import_joi48.default.object({
+      id: import_joi48.default.string().hex().required(),
+      value: import_joi48.default.object({
+        school: import_joi48.default.string().hex().optional(),
+        educationLevel: import_joi48.default.string().optional(),
+        gradeLevel: import_joi48.default.string().optional(),
+        teachingStyle: import_joi48.default.string().optional(),
+        maxTeachingHoursPerDay: import_joi48.default.number().integer().min(0).optional(),
+        maxTeachingHoursPerWeek: import_joi48.default.number().integer().min(0).optional(),
+        defaultStartTime: import_joi48.default.string().optional().allow("", null),
+        defaultEndTime: import_joi48.default.string().optional().allow("", null)
+      }).min(1)
+    });
+    const { error } = validation.validate({ id, value });
+    if (error) {
+      next(new import_nodejs_utils95.BadRequestError(error.message));
+      import_nodejs_utils95.logger.info(`Controller: ${error.message}`);
+      return;
+    }
+    try {
+      const result = await _updateById(id, value);
+      res.json({
+        message: "Successfully updated grade level.",
+        data: result
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi48.default.object({
+      page: import_joi48.default.number().min(1).optional().allow("", null),
+      limit: import_joi48.default.number().min(1).optional().allow("", null),
+      search: import_joi48.default.string().optional().allow("", null),
+      educationLevel: import_joi48.default.string().optional().allow("", null),
+      gradeLevel: import_joi48.default.string().optional().allow("", null),
+      teachingStyle: import_joi48.default.string().optional().allow("", null),
+      school: import_joi48.default.string().hex().optional().allow("", null),
+      status: import_joi48.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    if (error) {
+      next(new import_nodejs_utils95.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 educationLevel = req.query.educationLevel ?? "";
+    const gradeLevel = req.query.gradeLevel ?? "";
+    const teachingStyle = req.query.teachingStyle ?? "";
+    const school = req.query.school ?? "";
+    const search = req.query.search ?? "";
+    try {
+      const gradeLevels = await _getAll({
+        page,
+        limit,
+        sort: sortObj,
+        status,
+        educationLevel,
+        gradeLevel,
+        teachingStyle,
+        school,
+        search
+      });
+      res.json(gradeLevels);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi48.default.object({
+      id: import_joi48.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils95.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const gradeLevel = await _getById(id);
+      res.json({
+        message: "Successfully retrieved grade level.",
+        data: { gradeLevel }
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi48.default.object({
+      id: import_joi48.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils95.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _deleteById(id);
+      res.json({
+        message: "Successfully deleted grade level.",
+        data: result
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByEducationLevel(req, res, next) {
+    const educationLevel = req.params.educationLevel;
+    const school = req.query.school;
+    const validation = import_joi48.default.object({
+      educationLevel: import_joi48.default.string().required(),
+      school: import_joi48.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate({ educationLevel, school });
+    if (error) {
+      next(new import_nodejs_utils95.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const gradeLevels = await _getByEducationLevel(educationLevel, school);
+      res.json({
+        message: "Successfully retrieved grade levels by education level.",
+        data: { gradeLevels }
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById,
+    getByEducationLevel
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -30523,12 +32269,15 @@ function usePlantillaController() {
   MAsset,
   MBuilding,
   MBuildingUnit,
+  MCurriculum,
   MDivision,
   MEntity,
   MFile,
+  MGradeLevel,
   MMember,
   MONGO_DB,
   MONGO_URI,
+  MOffice,
   MOrder,
   MOrg,
   MPaymentMethod,
@@ -30569,7 +32318,10 @@ function usePlantillaController() {
   schemaAssetUpdateOption,
   schemaBuilding,
   schemaBuildingUnit,
+  schemaCurriculum,
   schemaDivision,
+  schemaGradeLevel,
+  schemaOffice,
   schemaPlantilla,
   schemaRegion,
   schemaSchool,
@@ -30587,6 +32339,8 @@ function usePlantillaController() {
   useBuildingUnitRepo,
   useCounterModel,
   useCounterRepo,
+  useCurriculumController,
+  useCurriculumRepo,
   useDivisionController,
   useDivisionRepo,
   useDivisionService,
@@ -30596,12 +32350,17 @@ function usePlantillaController() {
   useFileRepo,
   useFileService,
   useGitHubService,
+  useGradeLevelController,
+  useGradeLevelRepo,
   useInvoiceController,
   useInvoiceModel,
   useInvoiceRepo,
   useInvoiceService,
   useMemberController,
   useMemberRepo,
+  useOfficeController,
+  useOfficeRepo,
+  useOfficeService,
   useOrderController,
   useOrderRepo,
   useOrgController,