@goweekdays/core 2.9.0 → 2.10.0

package/dist/index.js

@@ -156,6 +156,7 @@ __export(src_exports, {
   usePlanController: () => usePlanController,
   usePlanRepo: () => usePlanRepo,
   usePlanService: () => usePlanService,
+  usePromoController: () => usePromoController,
   usePromoRepo: () => usePromoRepo,
   useRoleController: () => useRoleController,
   useRoleRepo: () => useRoleRepo,
@@ -1266,6 +1267,7 @@ function useMemberRepo() {
       await collection.createIndexes([
         { key: { name: 1 } },
         { key: { status: 1 } },
+        { key: { org: 1 } },
         { key: { name: "text", orgName: "text" }, name: "text_index" },
         {
           key: {
@@ -1971,6 +1973,38 @@ function useMemberRepo() {
       );
     }
   }
+  async function updateStatusByOrg(org, status, session) {
+    const { error } = import_joi4.default.object({
+      org: import_joi4.default.string().hex().length(24).required(),
+      status: import_joi4.default.string().valid("active", "suspended").required()
+    }).validate({ org, status });
+    if (error) {
+      throw new import_utils7.BadRequestError(error.message);
+    }
+    try {
+      org = new import_mongodb7.ObjectId(org);
+    } catch (error2) {
+      throw new import_utils7.BadRequestError("Invalid organization ID.");
+    }
+    try {
+      await collection.updateMany(
+        { org, status: { $ne: "deleted" }, app: { $ne: "org" } },
+        {
+          $set: {
+            status,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        },
+        { session }
+      );
+      delCachedData();
+      return "Successfully updated member statuses by organization.";
+    } catch (error2) {
+      throw new import_utils7.InternalServerError(
+        "Internal server error, failed to update member statuses."
+      );
+    }
+  }
   return {
     createIndexes,
     add,
@@ -1988,7 +2022,8 @@ function useMemberRepo() {
     getByApp,
     updateRoleById,
     updateStatusById,
-    deleteById
+    deleteById,
+    updateStatusByOrg
   };
 }
 
@@ -3578,8 +3613,13 @@ function useAppService() {
       },
       {
         code: "job",
-        name: "jobs",
+        name: "Jobs",
         description: "Job listings and recruitment services."
+      },
+      {
+        code: "circle",
+        name: "Circle",
+        description: "Community-based rotational system"
       }
     ];
     const session = import_utils17.useAtlas.getClient()?.startSession();
@@ -4397,7 +4437,8 @@ var schema = {
   name: import_joi15.default.string().max(255).required(),
   description: import_joi15.default.string().max(1024).optional().allow("", null),
   email: import_joi15.default.string().email().max(255).required(),
-  contact: import_joi15.default.string().max(50).optional().allow("", null)
+  contact: import_joi15.default.string().max(50).optional().allow("", null),
+  promoCode: import_joi15.default.string().max(50).optional().allow("", null)
 };
 var schemaOrg = import_joi15.default.object({
   ...schema,
@@ -4431,6 +4472,7 @@ function modelOrg(value) {
     email: value.email,
     contact: value.contact,
     createdBy: value.createdBy,
+    promoCode: value.promoCode ?? "",
     status: value.status ?? "active",
     createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
     updatedAt: "",
@@ -5463,7 +5505,7 @@ function useSubscriptionRepo() {
     search = "",
     status = "active"
   } = {}) {
-    page = page < 1 ? page - 1 : page;
+    page = page > 0 ? page - 1 : page;
     const query = { status };
     const cacheKeyOptions = {
       page,
@@ -7549,6 +7591,7 @@ function useSubscriptionService() {
     }
   }
   const { getOverdueForSuspension } = useSubscriptionRepo();
+  const { updateStatusByOrg } = useMemberRepo();
   async function processSuspensions() {
     const DAYS_OVERDUE = 7;
     while (true) {
@@ -7570,8 +7613,10 @@ function useSubscriptionService() {
           session.startTransaction();
           await updateStatusById(subId, "suspended", session);
           await updateRetryById(subId, 0, session);
-          if (subscription.org) {
-            await updateOrgStatusById(subscription.org, "suspended", session);
+          const orgId = String(subscription.org);
+          if (orgId) {
+            await updateOrgStatusById(orgId, "suspended", session);
+            await updateStatusByOrg(orgId, "suspended", session);
           }
           await session.commitTransaction();
           import_utils39.logger.log({
@@ -7635,6 +7680,7 @@ function useSubscriptionService() {
         session
       );
       await updateOrgStatusById(orgId, "active", session);
+      await updateStatusByOrg(orgId, "active", session);
       await updateLedgerStatusById(String(ledgerBill._id), "paid", session);
       await session.commitTransaction();
       return "Successfully processed paid invoice.";
@@ -7714,7 +7760,8 @@ function useSubscriptionController() {
     const validation = import_joi33.default.object({
       page: import_joi33.default.number().min(1).max(100).optional().allow(null, "").default(1),
       limit: import_joi33.default.number().min(1).max(100).optional().allow(null, "").default(10),
-      status: import_joi33.default.string().valid("active", "suspended").optional().default("active")
+      status: import_joi33.default.string().valid("active", "suspended").optional().default("active"),
+      search: import_joi33.default.string().optional().allow("", null)
     });
     const query = req.query;
     const { error, value } = validation.validate(query);
@@ -8205,6 +8252,14 @@ function useOrgService() {
   }
   const { getById, updateStatusById: updateVerificationStatus } = useVerificationRepo();
   const { add: addLedgerBilling } = useLedgerBillingRepo();
+  const MailerConfig = {
+    host: MAILER_TRANSPORT_HOST,
+    port: MAILER_TRANSPORT_PORT,
+    secure: MAILER_TRANSPORT_SECURE,
+    email: MAILER_EMAIL,
+    password: MAILER_PASSWORD
+  };
+  const mailer = new import_utils44.useMailer(MailerConfig);
   async function addWithVerification(id) {
     const { error } = import_joi36.default.string().hex().required().validate(id);
     if (error) {
@@ -8316,6 +8371,28 @@ function useOrgService() {
         },
         session
       );
+      const filePath = (0, import_utils44.getDirectory)(
+        __dirname,
+        "./public/handlebars/org-created"
+      );
+      const emailContent = (0, import_utils44.compileHandlebar)({
+        context: {
+          app: APP_ORG,
+          organization_name: verification.metadata.orgName
+        },
+        filePath
+      });
+      mailer.sendMail({
+        to: verification.email,
+        subject: "Welcome to GoWeekdays - Your Organization is Ready",
+        html: emailContent,
+        from: "GoWeekdays"
+      }).catch((error2) => {
+        import_utils44.logger.log({
+          level: "error",
+          message: `Error sending user invite email: ${error2}`
+        });
+      });
       await session?.commitTransaction();
       return "Successfully created organization with verification.";
     } catch (error2) {
@@ -11110,8 +11187,7 @@ function useFileController() {
 var import_joi45 = __toESM(require("joi"));
 var schemaPromo = import_joi45.default.object({
   code: import_joi45.default.string().min(3).max(50).required(),
-  description: import_joi45.default.string().max(255).optional().allow("", null),
-  type: import_joi45.default.string().valid("flat", "fixed", "tiered").required(),
+  type: import_joi45.default.string().valid("flat", "fixed", "volume").required(),
   flatRate: import_joi45.default.number().positive().when("type", {
     is: "flat",
     then: import_joi45.default.required(),
@@ -11133,9 +11209,12 @@ var schemaPromo = import_joi45.default.object({
     then: import_joi45.default.required(),
     otherwise: import_joi45.default.forbidden()
   }),
-  currency: import_joi45.default.string().length(3).required(),
-  startDate: import_joi45.default.date().required(),
-  endDate: import_joi45.default.date().greater(import_joi45.default.ref("startDate")).optional().allow(null, "")
+  currency: import_joi45.default.string().length(3).allow("PHP").required(),
+  startDate: import_joi45.default.date().optional().allow(null, ""),
+  endDate: import_joi45.default.date().greater(import_joi45.default.ref("startDate")).optional().allow(null, ""),
+  apps: import_joi45.default.array().items(import_joi45.default.string()).optional().allow(null),
+  seats: import_joi45.default.number().integer().min(0).optional().allow(null, 0),
+  usage: import_joi45.default.number().integer().min(0).optional().allow(null, 0)
 });
 function modelPromo(data) {
   const { error } = schemaPromo.validate(data);
@@ -11145,17 +11224,17 @@ function modelPromo(data) {
   return {
     _id: data._id,
     code: data.code,
-    description: data.description ?? "",
     type: data.type,
     flatRate: data.flatRate ?? 0,
     fixedRate: data.fixedRate ?? 0,
     tiers: data.tiers ?? [],
     currency: data.currency,
-    startDate: data.startDate ?? /* @__PURE__ */ new Date(),
+    startDate: data.startDate ?? "",
     endDate: data.endDate ?? "",
-    assignedTo: data.assignedTo ?? "",
+    seats: data.seats ?? 0,
+    usage: data.usage ?? 0,
+    apps: data.apps ?? [],
     status: data.status ?? "active",
-    assignedAt: data.assignedAt ?? "",
     createdAt: data.createdAt ?? /* @__PURE__ */ new Date(),
     updatedAt: data.updatedAt ?? "",
     deletedAt: data.deletedAt ?? ""
@@ -11171,7 +11250,7 @@ function usePromoRepo() {
   if (!db) {
     throw new import_utils61.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "users";
+  const namespace_collection = "promos";
   const collection = db.collection(namespace_collection);
   const { getCache, setCache, delNamespace } = (0, import_utils61.useCache)(namespace_collection);
   function delCachedData() {
@@ -11222,7 +11301,7 @@ function usePromoRepo() {
     search = "",
     status = "active"
   } = {}) {
-    page = page < 1 ? page - 1 : page;
+    page = page > 0 ? page - 1 : page;
     const query = { status };
     const cacheKeyOptions = {
       page,
@@ -11336,6 +11415,31 @@ function usePromoRepo() {
       throw new import_utils61.InternalServerError("Failed to get promo.");
     }
   }
+  async function updateById(_id, options) {
+    const { error: errorId } = import_joi46.default.string().hex().length(24).required().validate(_id);
+    if (errorId) {
+      throw new Error(`Invalid promo ID: ${errorId.message}`);
+    }
+    const { error } = schemaPromo.validate(options);
+    if (error) {
+      throw new Error(`Invalid promo ID: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb26.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils61.BadRequestError("Invalid promo ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...options, updatedAt: /* @__PURE__ */ new Date() } }
+      );
+      delCachedData();
+      return "Successfully updated promo.";
+    } catch (error2) {
+      throw new import_utils61.InternalServerError("Failed to update promo.");
+    }
+  }
   async function deleteById(_id) {
     const { error } = import_joi46.default.string().hex().length(24).required().validate(_id);
     if (error) {
@@ -11369,80 +11473,75 @@ function usePromoRepo() {
     getAll,
     getByCode,
     getById,
+    updateById,
     deleteById
   };
 }
 
-// src/resources/job-post/job.post.model.ts
+// src/resources/promo/promo.controller.ts
+var import_joi49 = __toESM(require("joi"));
+var import_utils65 = require("@goweekdays/utils");
+
+// src/resources/promo/promo.service.ts
+var import_utils64 = require("@goweekdays/utils");
+
+// src/resources/promo/promo.usage.repository.ts
+var import_utils63 = require("@goweekdays/utils");
+
+// src/resources/promo/promo.usage.model.ts
 var import_utils62 = require("@goweekdays/utils");
 var import_joi47 = __toESM(require("joi"));
 var import_mongodb27 = require("mongodb");
-var schemaJobPost = import_joi47.default.object({
-  _id: import_joi47.default.string().hex().optional(),
-  org: import_joi47.default.string().hex().required(),
-  title: import_joi47.default.string().trim().required(),
-  setup: import_joi47.default.string().trim().required(),
-  location: import_joi47.default.string().trim().required(),
-  type: import_joi47.default.string().trim().required(),
-  description: import_joi47.default.string().trim().required(),
-  status: import_joi47.default.string().trim().optional().allow("", null),
-  createdAt: import_joi47.default.date().optional(),
-  updatedAt: import_joi47.default.date().optional(),
-  deletedAt: import_joi47.default.date().optional()
+var schemaPromoUsage = import_joi47.default.object({
+  promo: import_joi47.default.string().hex().length(24).required(),
+  org: import_joi47.default.string().hex().length(24).required(),
+  usedBy: import_joi47.default.string().email().required()
 });
-var schemaJobPostUpdate = import_joi47.default.object({
-  _id: import_joi47.default.string().hex().required(),
-  title: import_joi47.default.string().trim().required(),
-  setup: import_joi47.default.string().trim().required(),
-  location: import_joi47.default.string().trim().required(),
-  type: import_joi47.default.string().trim().required(),
-  description: import_joi47.default.string().trim().required()
-});
-function modelJobPost(value) {
-  const { error } = schemaJobPost.validate(value);
+function modelPromoUsage(value) {
+  const { error } = schemaPromoUsage.validate(value);
   if (error) {
-    throw new import_utils62.BadRequestError(`Invalid job post: ${error.message}`);
+    throw new Error(`Invalid Promo Usage model: ${error.message}`);
   }
-  if (!value._id) {
+  if (value._id && typeof value._id === "string") {
     try {
-      value._id = new import_mongodb27.ObjectId();
+      value._id = new import_mongodb27.ObjectId(value._id);
     } catch (error2) {
-      throw new import_utils62.BadRequestError("Invalid job post ID.");
+      throw new import_utils62.BadRequestError("Invalid Promo Usage _id");
     }
   }
-  try {
-    value.org = new import_mongodb27.ObjectId(value.org);
-  } catch (error2) {
-    throw new import_utils62.BadRequestError("Invalid Org ID");
+  if (typeof value.promo === "string") {
+    try {
+      value.promo = new import_mongodb27.ObjectId(value.promo);
+    } catch (error2) {
+      throw new import_utils62.BadRequestError("Invalid Promo Usage promo");
+    }
+  }
+  if (typeof value.org === "string") {
+    try {
+      value.org = new import_mongodb27.ObjectId(value.org);
+    } catch (error2) {
+      throw new import_utils62.BadRequestError("Invalid Promo Usage org");
+    }
   }
   return {
     _id: value._id,
+    promo: value.promo,
     org: value.org,
-    title: value.title,
-    setup: value.setup,
-    location: value.location,
-    type: value.type,
-    description: value.description,
-    status: value.status ?? "draft",
-    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
-    updatedAt: value.updatedAt,
-    deletedAt: value.deletedAt
+    usedBy: value.usedBy,
+    createdAt: value.createdAt ? new Date(value.createdAt) : /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? ""
   };
 }
 
-// src/resources/job-post/job.post.controller.ts
-var import_joi49 = __toESM(require("joi"));
-var import_utils65 = require("@goweekdays/utils");
-
-// src/resources/job-post/job.post.repository.ts
-var import_utils63 = require("@goweekdays/utils");
+// src/resources/promo/promo.usage.repository.ts
+var import_joi48 = __toESM(require("joi"));
 var import_mongodb28 = require("mongodb");
-function useJobPostRepo() {
+function usePromoUsageRepo() {
   const db = import_utils63.useAtlas.getDb();
   if (!db) {
-    throw new import_utils63.BadRequestError("Unable to connect to server.");
+    throw new import_utils63.InternalServerError("Unable to connect to server.");
   }
-  const namespace_collection = "job.posts";
+  const namespace_collection = "promo.usages";
   const collection = db.collection(namespace_collection);
   const { getCache, setCache, delNamespace } = (0, import_utils63.useCache)(namespace_collection);
   function delCachedData() {
@@ -11461,185 +11560,686 @@ function useJobPostRepo() {
   async function createIndexes() {
     try {
       await collection.createIndexes([
-        { key: { title: 1 } },
-        { key: { setup: 1 } },
-        { key: { location: 1 } },
-        { key: { type: 1 } },
         {
-          key: {
-            title: "text",
-            setup: "text",
-            location: "text",
-            type: "text"
-          },
-          name: "jobpost_text_search"
+          key: { promo: 1, org: 1 },
+          name: "promo_org_index"
+        },
+        {
+          key: { usedBy: 1 },
+          name: "usedBy_index"
         }
       ]);
-      return "Successfully created job post indexes.";
     } catch (error) {
-      throw new import_utils63.BadRequestError("Failed to create job post indexes.");
     }
   }
-  async function add(value, session) {
+  async function add(value) {
     try {
-      value = modelJobPost(value);
-      const res = await collection.insertOne(value, { session });
+      value = modelPromoUsage(value);
+      await collection.insertOne(value);
       delCachedData();
-      return res.insertedId;
+      return "Successfully added promo usage.";
     } catch (error) {
-      import_utils63.logger.log({
-        level: "error",
-        message: error.message
-      });
-      throw new import_utils63.BadRequestError(`Failed to create job post: ${error.message}`);
+      throw new import_utils63.InternalServerError("Failed to add promo usage.");
     }
   }
   async function getAll({
-    search = "",
     page = 1,
     limit = 10,
-    status = "active"
+    promo,
+    org
   } = {}) {
-    page = page > 0 ? page - 1 : 0;
-    const query = { status };
-    if (search) {
-      query.$text = { $search: search };
-    }
-    const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, {
-      search,
+    page = page > 0 ? page - 1 : page;
+    const query = {};
+    const cacheKeyOptions = {
       page,
       limit,
-      status
-    });
-    import_utils63.logger.log({
-      level: "info",
-      message: `Cache key for getAll job posts: ${cacheKey}`
-    });
+      promo,
+      org,
+      tag: "getAll"
+    };
+    if (promo) {
+      try {
+        query.promo = new import_mongodb28.ObjectId(promo);
+      } catch (error) {
+        throw new import_utils63.BadRequestError("Invalid promo ID.");
+      }
+    }
+    if (org) {
+      try {
+        query.org = new import_mongodb28.ObjectId(org);
+      } catch (error) {
+        throw new import_utils63.BadRequestError("Invalid org ID.");
+      }
+    }
+    const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, cacheKeyOptions);
     try {
-      const cached = await getCache(cacheKey);
-      if (cached) {
-        import_utils63.logger.log({
-          level: "info",
-          message: `Cache hit for getAll job posts: ${cacheKey}`
-        });
-        return cached;
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
       }
       const items = await collection.aggregate([
         { $match: query },
         { $skip: page * limit },
-        { $limit: limit },
-        {
-          $project: {
-            _id: 1,
-            title: 1,
-            setup: 1,
-            location: 1,
-            type: 1,
-            createdAt: 1
-          }
-        }
+        { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
       const data = (0, import_utils63.paginate)(items, page, limit, length);
-      setCache(cacheKey, data, 600).then(() => {
+      setCache(cacheKey, data).then(() => {
         import_utils63.logger.log({
           level: "info",
-          message: `Cache set for getAll job posts: ${cacheKey}`
+          message: `Cache set for getAll promo usage: ${cacheKey}`
         });
       }).catch((err) => {
         import_utils63.logger.log({
           level: "error",
-          message: `Failed to set cache for getAll job posts: ${err.message}`
+          message: `Failed to set cache for getAll promo usage: ${err.message}`
         });
       });
       return data;
     } catch (error) {
-      import_utils63.logger.log({ level: "error", message: `${error}` });
-      throw error;
+      throw new import_utils63.InternalServerError("Failed to get promo usages.");
     }
   }
-  async function getJobPostsByOrg({
-    search = "",
-    page = 1,
-    limit = 10,
-    org = "",
-    status = "active"
-  } = {}) {
-    page = page > 0 ? page - 1 : 0;
-    try {
-      org = new import_mongodb28.ObjectId(org);
-    } catch (error) {
-      throw new import_utils63.BadRequestError("Invalid organization ID.");
+  async function getByPromo(promo) {
+    const { error } = import_joi48.default.string().hex().length(24).required().validate(promo);
+    if (error) {
+      throw new Error(`Invalid promo ID: ${error.message}`);
     }
-    const query = { org, status };
-    const cacheKeyOptions = {
-      org: String(org),
-      status,
-      limit,
-      page
-    };
-    if (search) {
-      cacheKeyOptions.search = search;
-      query.$text = { $search: search };
+    try {
+      promo = new import_mongodb28.ObjectId(promo);
+    } catch (error2) {
+      throw new import_utils63.BadRequestError("Invalid promo ID.");
     }
     try {
-      const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, cacheKeyOptions);
-      const cached = await getCache(
-        cacheKey
-      );
-      if (cached) {
-        import_utils63.logger.log({
-          level: "info",
-          message: `Cache hit for getJobPostsByOrg : ${cacheKey}`
-        });
-        return cached;
+      const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, {
+        promo: String(promo),
+        tag: "getByPromoId"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
       }
-      const items = await collection.aggregate([
-        { $match: query },
-        { $skip: page * limit },
-        { $limit: limit },
-        {
-          $project: {
-            _id: 1,
-            title: 1,
-            setup: 1,
-            location: 1,
-            type: 1,
-            createdAt: 1
-          }
-        }
-      ]).toArray();
-      const length = await collection.countDocuments(query);
-      const data = (0, import_utils63.paginate)(items, page, limit, length);
-      setCache(cacheKey, data, 300).then(() => {
+      const data = await collection.findOne({ promo });
+      setCache(cacheKey, data).then(() => {
         import_utils63.logger.log({
           level: "info",
-          message: `Cache set for getJobPostsByOrg: ${cacheKey}`
+          message: `Cache set for getByPromoId promo usage: ${cacheKey}`
         });
       }).catch((err) => {
         import_utils63.logger.log({
           level: "error",
-          message: `Failed to set cache for getJobPostsByOrg: ${err.message}`
+          message: `Failed to set cache for getByPromoId promo usage: ${err.message}`
         });
       });
       return data;
-    } catch (error) {
-      throw new import_utils63.InternalServerError(
-        "Internal server error, failed to retrieve job posts."
-      );
+    } catch (error2) {
+      throw new import_utils63.InternalServerError("Failed to get promo usages.");
     }
   }
   async function getById(_id) {
+    const { error } = import_joi48.default.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid promo usage ID: ${error.message}`);
+    }
     try {
       _id = new import_mongodb28.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils63.BadRequestError("Invalid promo usage ID.");
+    }
+    try {
+      const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, {
+        _id: String(_id),
+        tag: "getById"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const data = await collection.findOne({ _id });
+      setCache(cacheKey, data).then(() => {
+        import_utils63.logger.log({
+          level: "info",
+          message: `Cache set for getById promo usage: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils63.logger.log({
+          level: "error",
+          message: `Failed to set cache for getById promo usage: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new import_utils63.InternalServerError("Failed to get promo usage.");
+    }
+  }
+  async function getByOrgId(orgId) {
+    const { error } = import_joi48.default.string().hex().length(24).required().validate(orgId);
+    if (error) {
+      throw new Error(`Invalid org ID: ${error.message}`);
+    }
+    try {
+      orgId = new import_mongodb28.ObjectId(orgId);
+    } catch (error2) {
+      throw new import_utils63.BadRequestError("Invalid org ID.");
+    }
+    try {
+      const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, {
+        org: String(orgId),
+        tag: "getByOrgId"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        return cachedData;
+      }
+      const data = await collection.find({ org: orgId }).toArray();
+      setCache(cacheKey, data).then(() => {
+        import_utils63.logger.log({
+          level: "info",
+          message: `Cache set for getByOrgId promo usage: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils63.logger.log({
+          level: "error",
+          message: `Failed to set cache for getByOrgId promo usage: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error2) {
+      throw new import_utils63.InternalServerError("Failed to get promo usages.");
+    }
+  }
+  async function countByPromoId(promoId) {
+    const { error } = import_joi48.default.string().hex().length(24).required().validate(promoId);
+    if (error) {
+      throw new Error(`Invalid promo ID: ${error.message}`);
+    }
+    try {
+      promoId = new import_mongodb28.ObjectId(promoId);
+    } catch (error2) {
+      throw new import_utils63.BadRequestError("Invalid promo ID.");
+    }
+    try {
+      const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, {
+        promo: String(promoId),
+        tag: "countByPromoId"
+      });
+      const cachedData = await getCache(cacheKey);
+      if (cachedData !== null && cachedData !== void 0) {
+        return cachedData;
+      }
+      const count = await collection.countDocuments({ promo: promoId });
+      setCache(cacheKey, count).then(() => {
+        import_utils63.logger.log({
+          level: "info",
+          message: `Cache set for countByPromoId promo usage: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils63.logger.log({
+          level: "error",
+          message: `Failed to set cache for countByPromoId promo usage: ${err.message}`
+        });
+      });
+      return count;
+    } catch (error2) {
+      throw new import_utils63.InternalServerError("Failed to count promo usages.");
+    }
+  }
+  async function deleteById(_id) {
+    const { error } = import_joi48.default.string().hex().length(24).required().validate(_id);
+    if (error) {
+      throw new Error(`Invalid promo usage ID: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb28.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils63.BadRequestError("Invalid promo usage ID.");
+    }
+    try {
+      const result = await collection.deleteOne({ _id });
+      if (result.deletedCount === 0) {
+        throw new import_utils63.InternalServerError("Failed to delete promo usage.");
+      }
+      delCachedData();
+      return "Successfully deleted promo usage.";
+    } catch (error2) {
+      if (error2 instanceof import_utils63.AppError) {
+        throw error2;
+      }
+      throw new import_utils63.InternalServerError("Failed to delete promo usage.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getByPromo,
+    getById,
+    getByOrgId,
+    countByPromoId,
+    deleteById
+  };
+}
+
+// src/resources/promo/promo.service.ts
+function usePromoService() {
+  const { getByPromo } = usePromoUsageRepo();
+  const { deleteById: _deleteById } = usePromoRepo();
+  async function deleteById(id) {
+    const usage = await getByPromo(id);
+    if (usage) {
+      throw new import_utils64.BadRequestError("Failed to delete, promo is in use.");
+    }
+    try {
+      await _deleteById(id);
+      return "Successfully deleted promo.";
     } catch (error) {
-      throw new import_utils63.BadRequestError("Invalid ID.");
+      if (error instanceof import_utils64.AppError) {
+        throw error;
+      }
+      throw new import_utils64.BadRequestError("Failed to delete promo.");
     }
-    const cacheKey = (0, import_utils63.makeCacheKey)(namespace_collection, { _id: String(_id) });
+  }
+  return {
+    deleteById
+  };
+}
+
+// src/resources/promo/promo.controller.ts
+function usePromoController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getByCode: _getByCode,
+    getById: _getById,
+    updateById: _updateById
+  } = usePromoRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaPromo.validate(value);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _add(value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const status = req.query.status ?? "active";
+    const search = req.query.search ?? "";
+    const page = Number(req.query.page) ?? 1;
+    const limit = Number(req.query.limit) ?? 10;
+    const validation = import_joi49.default.object({
+      status: import_joi49.default.string().required(),
+      search: import_joi49.default.string().optional().allow("", null),
+      page: import_joi49.default.number().required(),
+      limit: import_joi49.default.number().required()
+    });
+    const { error } = validation.validate({ status, search, page, limit });
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const promos = await _getAll({ status, search, page, limit });
+      res.json(promos);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByCode(req, res, next) {
+    const code = req.params.code;
+    const validation = import_joi49.default.string().min(3).max(50).required();
+    const { error } = validation.validate(code);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const promo = await _getByCode(code);
+      res.json(promo);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi49.default.string().hex().length(24).required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const promo = await _getById(id);
+      res.json(promo);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateById(req, res, next) {
+    const id = req.params.id;
+    const value = req.body;
+    const validationId = import_joi49.default.string().hex().length(24).required();
+    const { error: errorId } = validationId.validate(id);
+    if (errorId) {
+      next(new import_utils65.BadRequestError(errorId.message));
+      return;
+    }
+    const { error } = schemaPromo.validate(value);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateById(id, value);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  const { deleteById: _deleteById } = usePromoService();
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi49.default.string().hex().length(24).required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getByCode,
+    getById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/job-post/job.post.model.ts
+var import_utils66 = require("@goweekdays/utils");
+var import_joi50 = __toESM(require("joi"));
+var import_mongodb29 = require("mongodb");
+var schemaJobPost = import_joi50.default.object({
+  _id: import_joi50.default.string().hex().optional(),
+  org: import_joi50.default.string().hex().required(),
+  title: import_joi50.default.string().trim().required(),
+  setup: import_joi50.default.string().trim().required(),
+  location: import_joi50.default.string().trim().required(),
+  type: import_joi50.default.string().trim().required(),
+  description: import_joi50.default.string().trim().required(),
+  status: import_joi50.default.string().trim().optional().allow("", null),
+  createdAt: import_joi50.default.date().optional(),
+  updatedAt: import_joi50.default.date().optional(),
+  deletedAt: import_joi50.default.date().optional()
+});
+var schemaJobPostUpdate = import_joi50.default.object({
+  _id: import_joi50.default.string().hex().required(),
+  title: import_joi50.default.string().trim().required(),
+  setup: import_joi50.default.string().trim().required(),
+  location: import_joi50.default.string().trim().required(),
+  type: import_joi50.default.string().trim().required(),
+  description: import_joi50.default.string().trim().required()
+});
+function modelJobPost(value) {
+  const { error } = schemaJobPost.validate(value);
+  if (error) {
+    throw new import_utils66.BadRequestError(`Invalid job post: ${error.message}`);
+  }
+  if (!value._id) {
+    try {
+      value._id = new import_mongodb29.ObjectId();
+    } catch (error2) {
+      throw new import_utils66.BadRequestError("Invalid job post ID.");
+    }
+  }
+  try {
+    value.org = new import_mongodb29.ObjectId(value.org);
+  } catch (error2) {
+    throw new import_utils66.BadRequestError("Invalid Org ID");
+  }
+  return {
+    _id: value._id,
+    org: value.org,
+    title: value.title,
+    setup: value.setup,
+    location: value.location,
+    type: value.type,
+    description: value.description,
+    status: value.status ?? "draft",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt,
+    deletedAt: value.deletedAt
+  };
+}
+
+// src/resources/job-post/job.post.controller.ts
+var import_joi52 = __toESM(require("joi"));
+var import_utils69 = require("@goweekdays/utils");
+
+// src/resources/job-post/job.post.repository.ts
+var import_utils67 = require("@goweekdays/utils");
+var import_mongodb30 = require("mongodb");
+function useJobPostRepo() {
+  const db = import_utils67.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils67.BadRequestError("Unable to connect to server.");
+  }
+  const namespace_collection = "job.posts";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_utils67.useCache)(namespace_collection);
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_utils67.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_utils67.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { title: 1 } },
+        { key: { setup: 1 } },
+        { key: { location: 1 } },
+        { key: { type: 1 } },
+        {
+          key: {
+            title: "text",
+            setup: "text",
+            location: "text",
+            type: "text"
+          },
+          name: "jobpost_text_search"
+        }
+      ]);
+      return "Successfully created job post indexes.";
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Failed to create job post indexes.");
+    }
+  }
+  async function add(value, session) {
+    try {
+      value = modelJobPost(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_utils67.logger.log({
+        level: "error",
+        message: error.message
+      });
+      throw new import_utils67.BadRequestError(`Failed to create job post: ${error.message}`);
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = { status };
+    if (search) {
+      query.$text = { $search: search };
+    }
+    const cacheKey = (0, import_utils67.makeCacheKey)(namespace_collection, {
+      search,
+      page,
+      limit,
+      status
+    });
+    import_utils67.logger.log({
+      level: "info",
+      message: `Cache key for getAll job posts: ${cacheKey}`
+    });
     try {
       const cached = await getCache(cacheKey);
       if (cached) {
-        import_utils63.logger.log({
+        import_utils67.logger.log({
+          level: "info",
+          message: `Cache hit for getAll job posts: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit },
+        {
+          $project: {
+            _id: 1,
+            title: 1,
+            setup: 1,
+            location: 1,
+            type: 1,
+            createdAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils67.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 600).then(() => {
+        import_utils67.logger.log({
+          level: "info",
+          message: `Cache set for getAll job posts: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils67.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll job posts: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      import_utils67.logger.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
+  async function getJobPostsByOrg({
+    search = "",
+    page = 1,
+    limit = 10,
+    org = "",
+    status = "active"
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    try {
+      org = new import_mongodb30.ObjectId(org);
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Invalid organization ID.");
+    }
+    const query = { org, status };
+    const cacheKeyOptions = {
+      org: String(org),
+      status,
+      limit,
+      page
+    };
+    if (search) {
+      cacheKeyOptions.search = search;
+      query.$text = { $search: search };
+    }
+    try {
+      const cacheKey = (0, import_utils67.makeCacheKey)(namespace_collection, cacheKeyOptions);
+      const cached = await getCache(
+        cacheKey
+      );
+      if (cached) {
+        import_utils67.logger.log({
+          level: "info",
+          message: `Cache hit for getJobPostsByOrg : ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $skip: page * limit },
+        { $limit: limit },
+        {
+          $project: {
+            _id: 1,
+            title: 1,
+            setup: 1,
+            location: 1,
+            type: 1,
+            createdAt: 1
+          }
+        }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      const data = (0, import_utils67.paginate)(items, page, limit, length);
+      setCache(cacheKey, data, 300).then(() => {
+        import_utils67.logger.log({
+          level: "info",
+          message: `Cache set for getJobPostsByOrg: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_utils67.logger.log({
+          level: "error",
+          message: `Failed to set cache for getJobPostsByOrg: ${err.message}`
+        });
+      });
+      return data;
+    } catch (error) {
+      throw new import_utils67.InternalServerError(
+        "Internal server error, failed to retrieve job posts."
+      );
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb30.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Invalid ID.");
+    }
+    const cacheKey = (0, import_utils67.makeCacheKey)(namespace_collection, { _id: String(_id) });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_utils67.logger.log({
           level: "info",
           message: `Cache hit for getById job post: ${cacheKey}`
         });
@@ -11647,37 +12247,37 @@ function useJobPostRepo() {
       }
       const result = await collection.findOne({ _id });
       if (!result) {
-        throw new import_utils63.BadRequestError("Job post not found.");
+        throw new import_utils67.BadRequestError("Job post not found.");
       }
       setCache(cacheKey, result, 300).then(() => {
-        import_utils63.logger.log({
+        import_utils67.logger.log({
           level: "info",
           message: `Cache set for job post by id: ${cacheKey}`
         });
       }).catch((err) => {
-        import_utils63.logger.log({
+        import_utils67.logger.log({
           level: "error",
           message: `Failed to set cache for job post by id: ${err.message}`
         });
       });
       return result;
     } catch (error) {
-      if (error instanceof import_utils63.AppError) {
+      if (error instanceof import_utils67.AppError) {
         throw error;
       } else {
-        throw new import_utils63.InternalServerError("Failed to get job post.");
+        throw new import_utils67.InternalServerError("Failed to get job post.");
       }
     }
   }
   async function updateById(_id, options) {
     const { error } = schemaJobPostUpdate.validate({ ...options, _id });
     if (error) {
-      throw new import_utils63.BadRequestError(error.message);
+      throw new import_utils67.BadRequestError(error.message);
     }
     try {
-      _id = new import_mongodb28.ObjectId(_id);
+      _id = new import_mongodb30.ObjectId(_id);
     } catch (error2) {
-      throw new import_utils63.BadRequestError("Invalid JobPost ID.");
+      throw new import_utils67.BadRequestError("Invalid JobPost ID.");
     }
     try {
       await collection.updateOne(
@@ -11687,14 +12287,14 @@ function useJobPostRepo() {
       delCachedData();
       return "Successfully updated job post.";
     } catch (error2) {
-      throw new import_utils63.InternalServerError("Failed to update job post.");
+      throw new import_utils67.InternalServerError("Failed to update job post.");
     }
   }
   async function deleteById(_id, session) {
     try {
-      _id = new import_mongodb28.ObjectId(_id);
+      _id = new import_mongodb30.ObjectId(_id);
     } catch (error) {
-      throw new import_utils63.BadRequestError("Invalid ID.");
+      throw new import_utils67.BadRequestError("Invalid ID.");
     }
     try {
       await collection.updateOne(
@@ -11711,7 +12311,35 @@ function useJobPostRepo() {
       delCachedData();
       return "Successfully deleted job post.";
     } catch (error) {
-      throw new import_utils63.InternalServerError("Failed to delete job post.");
+      throw new import_utils67.InternalServerError("Failed to delete job post.");
+    }
+  }
+  async function updateStatusById(_id, status) {
+    try {
+      _id = new import_mongodb30.ObjectId(_id);
+    } catch (error) {
+      throw new import_utils67.BadRequestError("Invalid ID.");
+    }
+    try {
+      const result = await collection.updateOne(
+        { _id },
+        {
+          $set: {
+            status,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+      if (result.matchedCount === 0) {
+        throw new import_utils67.BadRequestError("Job post not found.");
+      }
+      delCachedData();
+      return "Successfully updated job post status.";
+    } catch (error) {
+      if (error instanceof import_utils67.AppError) {
+        throw error;
+      }
+      throw new import_utils67.InternalServerError("Failed to update job post status.");
     }
   }
   return {
@@ -11721,28 +12349,29 @@ function useJobPostRepo() {
     getJobPostsByOrg,
     getById,
     updateById,
-    deleteById
+    deleteById,
+    updateStatusById
   };
 }
 
 // src/resources/job-post/job.post.service.ts
-var import_utils64 = require("@goweekdays/utils");
-var import_joi48 = __toESM(require("joi"));
+var import_utils68 = require("@goweekdays/utils");
+var import_joi51 = __toESM(require("joi"));
 function useJobPostService() {
   const { deleteById: _deleteById } = useJobPostRepo();
   async function deleteById(id) {
-    const { error } = import_joi48.default.string().hex().required().validate(id);
+    const { error } = import_joi51.default.string().hex().required().validate(id);
     if (error) {
-      throw new import_utils64.BadRequestError(error.message);
+      throw new import_utils68.BadRequestError(error.message);
     }
     try {
       await _deleteById(id);
       return "Successfully deleted job post.";
     } catch (error2) {
-      if (error2 instanceof import_utils64.AppError) {
+      if (error2 instanceof import_utils68.AppError) {
         throw error2;
       } else {
-        throw new import_utils64.InternalServerError("Failed to delete job post.");
+        throw new import_utils68.InternalServerError("Failed to delete job post.");
       }
     }
   }
@@ -11758,15 +12387,16 @@ function useJobPostController() {
     getAll: _getAll,
     getJobPostsByOrg: _getJobPostsByOrg,
     getById: _getById,
-    updateById: _updateById
+    updateById: _updateById,
+    updateStatusById: _updateStatusById
   } = useJobPostRepo();
   const { deleteById: _deleteById } = useJobPostService();
   async function add(req, res, next) {
     const value = req.body;
     const { error } = schemaJobPost.validate(value);
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
-      import_utils65.logger.info(`Controller: ${error.message}`);
+      next(new import_utils69.BadRequestError(error.message));
+      import_utils69.logger.info(`Controller: ${error.message}`);
       return;
     }
     try {
@@ -11779,11 +12409,11 @@ function useJobPostController() {
   }
   async function getAll(req, res, next) {
     const query = req.query;
-    const validation = import_joi49.default.object({
-      page: import_joi49.default.number().min(1).optional().allow("", null),
-      limit: import_joi49.default.number().min(1).optional().allow("", null),
-      search: import_joi49.default.string().optional().allow("", null),
-      status: import_joi49.default.string().optional()
+    const validation = import_joi52.default.object({
+      page: import_joi52.default.number().min(1).optional().allow("", null),
+      limit: import_joi52.default.number().min(1).optional().allow("", null),
+      search: import_joi52.default.string().optional().allow("", null),
+      status: import_joi52.default.string().optional()
     });
     const { error } = validation.validate(query);
     const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
@@ -11792,16 +12422,16 @@ function useJobPostController() {
     const status = req.query.status ?? "active";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils65.BadRequestError("Invalid page number."));
+      next(new import_utils69.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils65.BadRequestError("Invalid limit number."));
+      next(new import_utils69.BadRequestError("Invalid limit number."));
       return;
     }
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils69.BadRequestError(error.message));
       return;
     }
     try {
@@ -11820,24 +12450,24 @@ function useJobPostController() {
     const org = req.params.org ?? "";
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils65.BadRequestError("Invalid page number."));
+      next(new import_utils69.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils65.BadRequestError("Invalid limit number."));
+      next(new import_utils69.BadRequestError("Invalid limit number."));
       return;
     }
-    const validation = import_joi49.default.object({
-      org: import_joi49.default.string().hex().required(),
-      page: import_joi49.default.number().min(1).optional().allow("", null),
-      limit: import_joi49.default.number().min(1).optional().allow("", null),
-      search: import_joi49.default.string().optional().allow("", null),
-      status: import_joi49.default.string().optional()
+    const validation = import_joi52.default.object({
+      org: import_joi52.default.string().hex().required(),
+      page: import_joi52.default.number().min(1).optional().allow("", null),
+      limit: import_joi52.default.number().min(1).optional().allow("", null),
+      search: import_joi52.default.string().optional().allow("", null),
+      status: import_joi52.default.string().optional()
     });
     const { error } = validation.validate({ org, page, limit, search, status });
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils69.BadRequestError(error.message));
       return;
     }
     try {
@@ -11850,12 +12480,12 @@ function useJobPostController() {
   }
   async function getById(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi49.default.object({
-      id: import_joi49.default.string().hex().required()
+    const validation = import_joi52.default.object({
+      id: import_joi52.default.string().hex().required()
     });
     const { error } = validation.validate({ id });
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils69.BadRequestError(error.message));
       return;
     }
     try {
@@ -11871,7 +12501,7 @@ function useJobPostController() {
     const payload = req.body;
     const { error } = schemaJobPostUpdate.validate({ _id, ...payload });
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils69.BadRequestError(error.message));
       return;
     }
     try {
@@ -11885,7 +12515,7 @@ function useJobPostController() {
   async function deleteById(req, res, next) {
     const id = req.params.id;
     if (!id) {
-      next(new import_utils65.BadRequestError("Job Post ID is required."));
+      next(new import_utils69.BadRequestError("Job Post ID is required."));
       return;
     }
     try {
@@ -11896,13 +12526,34 @@ function useJobPostController() {
       next(error);
     }
   }
+  async function updateStatusById(req, res, next) {
+    const id = req.params.id;
+    const status = req.params.status;
+    const validation = import_joi52.default.object({
+      id: import_joi52.default.string().hex().required(),
+      status: import_joi52.default.string().valid("draft", "open", "paused", "in-review", "closed").required()
+    });
+    const { error } = validation.validate({ id, status });
+    if (error) {
+      next(new import_utils69.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateStatusById(id, status);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   return {
     add,
     getAll,
     getJobPostsByOrg,
     getById,
     updateById,
-    deleteById
+    deleteById,
+    updateStatusById
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -12033,6 +12684,7 @@ function useJobPostController() {
   usePlanController,
   usePlanRepo,
   usePlanService,
+  usePromoController,
   usePromoRepo,
   useRoleController,
   useRoleRepo,