@eeplatform/core 1.4.2 → 1.4.4

package/dist/index.js

@@ -11354,6 +11354,7 @@ __export(src_exports, {
   MOrder: () => MOrder,
   MOrg: () => MOrg,
   MPaymentMethod: () => MPaymentMethod,
+  MPlantilla: () => MPlantilla,
   MPromoCode: () => MPromoCode,
   MRegion: () => MRegion,
   MRole: () => MRole,
@@ -11391,6 +11392,7 @@ __export(src_exports, {
   schemaBuilding: () => schemaBuilding,
   schemaBuildingUnit: () => schemaBuildingUnit,
   schemaDivision: () => schemaDivision,
+  schemaPlantilla: () => schemaPlantilla,
   schemaRegion: () => schemaRegion,
   schemaSchool: () => schemaSchool,
   schemaStockCard: () => schemaStockCard,
@@ -11415,6 +11417,7 @@ __export(src_exports, {
   useFileController: () => useFileController,
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
+  useGitHubService: () => useGitHubService,
   useInvoiceController: () => useInvoiceController,
   useInvoiceModel: () => useInvoiceModel,
   useInvoiceRepo: () => useInvoiceRepo,
@@ -11433,6 +11436,8 @@ __export(src_exports, {
   usePaymentModel: () => usePaymentModel,
   usePaymentRepo: () => usePaymentRepo,
   usePaypalService: () => usePaypalService,
+  usePlantillaController: () => usePlantillaController,
+  usePlantillaRepo: () => usePlantillaRepo,
   usePriceController: () => usePriceController,
   usePriceModel: () => usePriceModel,
   usePriceRepo: () => usePriceRepo,
@@ -11455,6 +11460,7 @@ __export(src_exports, {
   useUserController: () => useUserController,
   useUserRepo: () => useUserRepo,
   useUserService: () => useUserService,
+  useUtilController: () => useUtilController,
   useVerificationController: () => useVerificationController,
   useVerificationRepo: () => useVerificationRepo,
   useVerificationService: () => useVerificationService,
@@ -11512,6 +11518,24 @@ function useVerificationRepo() {
       });
     });
   }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { email: 1 } },
+        { key: { type: 1 } },
+        { key: { status: 1 } },
+        { key: { "metadata.org": 1 } },
+        { key: { email: "text" } },
+        {
+          key: { expiredAt: 1 },
+          expireAfterSeconds: 0,
+          name: "ttl_expiredAt_index"
+        }
+      ]);
+    } catch (error) {
+      throw new import_nodejs_utils2.InternalServerError("Failed to create indexes.");
+    }
+  }
   async function createIndex() {
     try {
       await collection.createIndex([
@@ -11734,9 +11758,7 @@ function useVerificationRepo() {
     }
   }
   return {
-    createIndex,
-    createTextIndex,
-    createUniqueIndex,
+    createIndexes,
     add,
     getVerifications,
     getById,
@@ -13121,7 +13143,7 @@ function useVerificationService() {
         type: "user-sign-up",
         email,
         metadata,
-        expireAt: new Date((/* @__PURE__ */ new Date()).getTime() + 5 * 60 * 1e3).toISOString(),
+        expireAt: new Date((/* @__PURE__ */ new Date()).getTime() + 5 * 60 * 1e3),
         // 5mins from now
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -25634,7 +25656,7 @@ function useRegionService() {
         {
           id: region.toString(),
           name: "Admin",
-          type: "region",
+          type: "basic-edu-ro",
           permissions: ["*"],
           status: "active",
           default: true
@@ -26186,7 +26208,7 @@ function useDivisionService() {
         {
           id: division.toString(),
           name: "Admin",
-          type: "division",
+          type: "basic-edu-sdo",
           permissions: ["*"],
           status: "active",
           default: true
@@ -29150,6 +29172,686 @@ function useStockCardController() {
     getSuppliers
   };
 }
+
+// src/services/github.service.ts
+var import_nodejs_utils80 = require("@eeplatform/nodejs-utils");
+var import_rest = require("@octokit/rest");
+var import_libsodium_wrappers = __toESM(require("libsodium-wrappers"));
+function useGitHubService() {
+  function parseRepoUrl(url2) {
+    const match = url2.match(/github\.com[:\/]([^\/]+)\/(.+)\.git$/);
+    if (!match)
+      throw new Error("Invalid GitHub repo URL");
+    return { owner: match[1], repo: match[2] };
+  }
+  async function checkAdminPermission(owner, repo, octokit) {
+    try {
+      const { data: repoData } = await octokit.repos.get({ owner, repo });
+      if (!repoData.permissions?.admin) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "You do not have admin access to this repository."
+        );
+      }
+    } catch (error) {
+      if (error.status === 404) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "Repository not found or you don't have access to it."
+        );
+      } else if (error.status === 401) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "Invalid GitHub token or insufficient permissions."
+        );
+      } else if (error.message.includes("admin access")) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils80.BadRequestError(
+          `Failed to check repository permissions: ${error.message}`
+        );
+      }
+    }
+  }
+  async function setVariables(params) {
+    try {
+      const { githubToken, repoUrl, environment, type, keyValues } = params;
+      const octokit = new import_rest.Octokit({ auth: githubToken });
+      const { owner, repo } = parseRepoUrl(repoUrl);
+      await checkAdminPermission(owner, repo, octokit);
+      const lines = keyValues.split(/[\n\r\s\t]+/).map((l) => l.trim()).filter(Boolean);
+      for (const line of lines) {
+        const equalIndex = line.indexOf("=");
+        if (equalIndex === -1)
+          continue;
+        const key = line.substring(0, equalIndex).trim();
+        const value = line.substring(equalIndex + 1).trim();
+        if (!key || !value)
+          continue;
+        if (type === "secret") {
+          const { data: publicKeyRes } = await octokit.actions.getEnvironmentPublicKey({
+            owner,
+            repo,
+            environment_name: environment
+          });
+          try {
+            await import_libsodium_wrappers.default.ready;
+            const sodium = import_libsodium_wrappers.default;
+            const publicKeyBase64 = publicKeyRes.key;
+            if (!publicKeyBase64) {
+              throw new Error("No public key received from GitHub");
+            }
+            const keyBytes = new Uint8Array(
+              Buffer.from(publicKeyBase64, "base64")
+            );
+            const valueBytes = new Uint8Array(Buffer.from(value, "utf8"));
+            const encryptedBytes = sodium.crypto_box_seal(valueBytes, keyBytes);
+            const encryptedValue = Buffer.from(encryptedBytes).toString("base64");
+            await octokit.actions.createOrUpdateEnvironmentSecret({
+              owner,
+              repo,
+              environment_name: environment,
+              secret_name: key,
+              encrypted_value: encryptedValue,
+              key_id: publicKeyRes.key_id
+            });
+          } catch (encryptionError) {
+            throw new import_nodejs_utils80.BadRequestError(
+              `Failed to encrypt secret '${key}': ${encryptionError.message}`
+            );
+          }
+        } else if (type === "env") {
+          await octokit.actions.createEnvironmentVariable({
+            owner,
+            repo,
+            environment_name: environment,
+            name: key,
+            value
+          });
+        }
+      }
+      return `Successfully set ${lines.length} ${type} variables/secrets in environment '${environment}'`;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils80.AppError)
+        throw error;
+      if (error.status === 422) {
+        throw new import_nodejs_utils80.BadRequestError(
+          `GitHub API validation error: ${error.message}`
+        );
+      } else if (error.status === 404) {
+        throw new import_nodejs_utils80.BadRequestError("Environment or repository not found.");
+      } else if (error.status === 403) {
+        throw new import_nodejs_utils80.BadRequestError(
+          "Forbidden: Insufficient permissions or rate limit exceeded."
+        );
+      } else if (error.message.includes("admin access") || error.message.includes("permissions")) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils80.BadRequestError(
+          `Failed to set GitHub variables: ${error.message}`
+        );
+      }
+    }
+  }
+  return {
+    setVariables
+  };
+}
+
+// src/controllers/util.controller.ts
+var import_joi40 = __toESM(require("joi"));
+var import_nodejs_utils81 = require("@eeplatform/nodejs-utils");
+function useUtilController() {
+  async function healthCheck(req, res, next) {
+    try {
+      res.status(200).json({
+        success: true,
+        message: "Util service is healthy",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          availableEndpoints: [
+            "POST /github/variables - Set GitHub environment variables or secrets"
+          ],
+          keyValueFormat: "KEY=value pairs separated by newlines, spaces, or tabs"
+        }
+      });
+    } catch (error) {
+      import_nodejs_utils81.logger.error("Health check failed", { error: error.message });
+      next(new import_nodejs_utils81.InternalServerError("Health check failed"));
+    }
+  }
+  async function setGitHubVariables(req, res, next) {
+    try {
+      const { githubToken, repoUrl, environment, type, keyValues } = req.body;
+      const validation = import_joi40.default.object({
+        githubToken: import_joi40.default.string().required().messages({
+          "string.empty": "GitHub token is required",
+          "any.required": "GitHub token is required"
+        }),
+        repoUrl: import_joi40.default.string().uri().required().messages({
+          "string.empty": "Repository URL is required",
+          "string.uri": "Repository URL must be a valid URL",
+          "any.required": "Repository URL is required"
+        }),
+        environment: import_joi40.default.string().required().messages({
+          "string.empty": "Environment name is required",
+          "any.required": "Environment name is required"
+        }),
+        type: import_joi40.default.string().valid("env", "secret").required().messages({
+          "any.only": 'Type must be either "env" or "secret"',
+          "any.required": "Type is required"
+        }),
+        keyValues: import_joi40.default.string().required().messages({
+          "string.empty": "Key-value pairs are required",
+          "any.required": "Key-value pairs are required"
+        })
+      });
+      const { error } = validation.validate({
+        githubToken,
+        repoUrl,
+        environment,
+        type,
+        keyValues
+      });
+      if (error) {
+        next(new import_nodejs_utils81.BadRequestError(error.message));
+        return;
+      }
+      const repoUrlPattern = /github\.com[:\/]([^\/]+)\/(.+)\.git$/;
+      if (!repoUrlPattern.test(repoUrl)) {
+        next(
+          new import_nodejs_utils81.BadRequestError(
+            "Invalid GitHub repository URL format. Expected format: https://github.com/owner/repo.git"
+          )
+        );
+        return;
+      }
+      const lines = keyValues.split(/[\n\r\s\t]+/).map((l) => l.trim()).filter(Boolean);
+      const invalidLines = lines.filter(
+        (line) => !line.includes("=") || line.indexOf("=") === -1
+      );
+      if (invalidLines.length > 0) {
+        next(
+          new import_nodejs_utils81.BadRequestError(
+            "Invalid key-value format. Each pair should be in format: KEY=value. Pairs can be separated by newlines, spaces, or tabs."
+          )
+        );
+        return;
+      }
+      const githubService = useGitHubService();
+      const result = await githubService.setVariables({
+        githubToken,
+        repoUrl,
+        environment,
+        type,
+        keyValues
+      });
+      import_nodejs_utils81.logger.info(`GitHub variables set successfully`, {
+        repoUrl,
+        environment,
+        type,
+        count: lines.length
+      });
+      res.status(200).json({
+        success: true,
+        message: result,
+        data: {
+          repoUrl,
+          environment,
+          type,
+          variablesSet: lines.length
+        }
+      });
+    } catch (error) {
+      import_nodejs_utils81.logger.error("Failed to set GitHub variables", {
+        error: error.message,
+        stack: error.stack
+      });
+      if (error instanceof import_nodejs_utils81.AppError) {
+        next(error);
+      } else {
+        next(
+          new import_nodejs_utils81.InternalServerError(
+            `Failed to set GitHub variables: ${error.message}`
+          )
+        );
+      }
+    }
+  }
+  return {
+    healthCheck,
+    setGitHubVariables
+  };
+}
+
+// src/models/plantilla.model.ts
+var import_nodejs_utils82 = require("@eeplatform/nodejs-utils");
+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, ""),
+  itemNumber: import_joi41.default.string().required(),
+  positionTitle: import_joi41.default.string().required(),
+  officeAssignmentType: import_joi41.default.string().required(),
+  officeAssignment: import_joi41.default.string().required(),
+  status: import_joi41.default.string().required(),
+  employeeId: import_joi41.default.string().hex().optional().allow(null, ""),
+  createdAt: import_joi41.default.date().iso().optional().allow(null, ""),
+  updatedAt: import_joi41.default.date().iso().optional().allow(null, ""),
+  deletedAt: import_joi41.default.date().iso().optional().allow(null, "")
+});
+function MPlantilla(data) {
+  const { error } = schemaPlantilla.validate(data);
+  if (error) {
+    throw new import_nodejs_utils82.BadRequestError(error.message);
+  }
+  if (data._id && typeof data._id === "string") {
+    try {
+      data._id = new import_mongodb46.ObjectId(data._id);
+    } catch (error2) {
+      throw new import_nodejs_utils82.BadRequestError("Invalid _id.");
+    }
+  }
+  if (data.employeeId && typeof data.employeeId === "string") {
+    try {
+      data.employeeId = new import_mongodb46.ObjectId(data.employeeId);
+    } catch (error2) {
+      throw new import_nodejs_utils82.BadRequestError("Invalid employeeId.");
+    }
+  }
+  return {
+    _id: data._id,
+    itemNumber: data.itemNumber ?? "",
+    positionTitle: data.positionTitle ?? "",
+    officeAssignmentType: data.officeAssignmentType ?? "",
+    officeAssignment: data.officeAssignment ?? "",
+    status: data.status ?? "active",
+    employeeId: data.employeeId,
+    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/plantilla.repository.ts
+var import_nodejs_utils83 = require("@eeplatform/nodejs-utils");
+var import_mongodb47 = require("mongodb");
+function usePlantillaRepo() {
+  const db = import_nodejs_utils83.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "plantillas";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils83.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 plantillas.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = MPlantilla(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils83.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils83.BadRequestError("Plantilla already exists.");
+        }
+        throw new Error("Failed to create plantilla.");
+      }
+    }
+  }
+  async function updateById(_id, value, session) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils83.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_utils83.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        throw new Error("Failed to update plantilla.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    org = "",
+    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 (org) {
+      try {
+        query.org = new import_mongodb47.ObjectId(org);
+      } catch (error) {
+        throw new import_nodejs_utils83.BadRequestError("Invalid org ID.");
+      }
+    }
+    const cacheParams = {
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search)
+      cacheParams.search = search;
+    if (org)
+      cacheParams.org = org;
+    if (status !== "active")
+      cacheParams.status = status;
+    const cacheKey = (0, import_nodejs_utils83.makeCacheKey)(namespace_collection, cacheParams);
+    import_nodejs_utils83.logger.log({
+      level: "info",
+      message: `Cache key for getAll plantillas: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache hit for getAll plantillas: ${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_utils83.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache set for getAll plantillas: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils83.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll plantillas: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_nodejs_utils83.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils83.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils83.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache hit for getById plantilla: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id
+      });
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils83.logger.log({
+          level: "info",
+          message: `Cache set for plantilla by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils83.logger.log({
+          level: "error",
+          message: `Failed to set cache for plantilla by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils83.InternalServerError("Failed to get plantilla.");
+      }
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb47.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils83.BadRequestError("Invalid ID.");
+    }
+    try {
+      const res = await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return res;
+    } catch (error) {
+      import_nodejs_utils83.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils83.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils83.InternalServerError("Failed to delete plantilla.");
+      }
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils83.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils83.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/controllers/plantilla.controller.ts
+var import_nodejs_utils84 = require("@eeplatform/nodejs-utils");
+var import_joi42 = __toESM(require("joi"));
+function usePlantillaController() {
+  const {
+    add: _addPlantilla,
+    getAll: _getAllPlantillas,
+    getById: _getPlantillaById,
+    updateById: _updatePlantillaById,
+    deleteById: _deletePlantillaById
+  } = usePlantillaRepo();
+  async function createPlantilla(req, res, next) {
+    const value = req.body;
+    const validation = import_joi42.default.object({
+      itemNumber: import_joi42.default.string().required(),
+      positionTitle: import_joi42.default.string().required(),
+      officeAssignmentType: import_joi42.default.string().required(),
+      officeAssignment: import_joi42.default.string().required(),
+      status: import_joi42.default.string().required(),
+      employeeId: import_joi42.default.string().hex().optional().allow(null, "")
+    });
+    const { error } = validation.validate(value);
+    if (error) {
+      next(new import_nodejs_utils84.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const id = await _addPlantilla(value);
+      res.json({ message: "Plantilla created successfully", id });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAllPlantillas(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 org = req.query.org ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils84.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils84.BadRequestError("Invalid limit number."));
+      return;
+    }
+    const validation = import_joi42.default.object({
+      page: import_joi42.default.number().min(1).optional().allow("", null),
+      limit: import_joi42.default.number().min(1).optional().allow("", null),
+      search: import_joi42.default.string().optional().allow("", null),
+      org: import_joi42.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate({ page, limit, search, org });
+    if (error) {
+      next(new import_nodejs_utils84.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const plantillas = await _getAllPlantillas({
+        search,
+        page,
+        limit,
+        org
+      });
+      res.json(plantillas);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getPlantillaById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi42.default.object({
+      id: import_joi42.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils84.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const plantilla = await _getPlantillaById(id);
+      if (!plantilla) {
+        next(new import_nodejs_utils84.BadRequestError("Plantilla not found."));
+        return;
+      }
+      res.json(plantilla);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updatePlantilla(req, res, next) {
+    const id = req.params.id;
+    const value = req.body;
+    const validation = import_joi42.default.object({
+      id: import_joi42.default.string().hex().required(),
+      employeeId: import_joi42.default.string().hex().optional().allow(null, ""),
+      status: import_joi42.default.string().optional(),
+      positionTitle: import_joi42.default.string().optional()
+    });
+    const { error } = validation.validate({ id, ...value });
+    if (error) {
+      next(new import_nodejs_utils84.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _updatePlantillaById(id, value);
+      if (result.matchedCount === 0) {
+        next(new import_nodejs_utils84.BadRequestError("Plantilla not found."));
+        return;
+      }
+      res.json({ message: "Plantilla updated successfully" });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deletePlantilla(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi42.default.object({
+      id: import_joi42.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils84.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const result = await _deletePlantillaById(id);
+      if (result.matchedCount === 0) {
+        next(new import_nodejs_utils84.BadRequestError("Plantilla not found."));
+        return;
+      }
+      res.json({ message: "Plantilla deleted successfully" });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    createPlantilla,
+    getAllPlantillas,
+    getPlantillaById,
+    updatePlantilla,
+    deletePlantilla
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -29181,6 +29883,7 @@ function useStockCardController() {
   MOrder,
   MOrg,
   MPaymentMethod,
+  MPlantilla,
   MPromoCode,
   MRegion,
   MRole,
@@ -29218,6 +29921,7 @@ function useStockCardController() {
   schemaBuilding,
   schemaBuildingUnit,
   schemaDivision,
+  schemaPlantilla,
   schemaRegion,
   schemaSchool,
   schemaStockCard,
@@ -29242,6 +29946,7 @@ function useStockCardController() {
   useFileController,
   useFileRepo,
   useFileService,
+  useGitHubService,
   useInvoiceController,
   useInvoiceModel,
   useInvoiceRepo,
@@ -29260,6 +29965,8 @@ function useStockCardController() {
   usePaymentModel,
   usePaymentRepo,
   usePaypalService,
+  usePlantillaController,
+  usePlantillaRepo,
   usePriceController,
   usePriceModel,
   usePriceRepo,
@@ -29282,6 +29989,7 @@ function useStockCardController() {
   useUserController,
   useUserRepo,
   useUserService,
+  useUtilController,
   useVerificationController,
   useVerificationRepo,
   useVerificationService,