@goweekdays/core 0.0.11 → 0.0.13

package/dist/index.js

@@ -11342,8 +11342,10 @@ __export(src_exports, {
   MMember: () => MMember,
   MONGO_DB: () => MONGO_DB,
   MONGO_URI: () => MONGO_URI,
+  MOrder: () => MOrder,
   MOrg: () => MOrg,
   MPaymentMethod: () => MPaymentMethod,
+  MPromoCode: () => MPromoCode,
   MRole: () => MRole,
   MSubscription: () => MSubscription,
   MToken: () => MToken,
@@ -11371,6 +11373,7 @@ __export(src_exports, {
   XENDIT_BASE_URL: () => XENDIT_BASE_URL,
   XENDIT_SECRET_KEY: () => XENDIT_SECRET_KEY,
   isDev: () => isDev,
+  schema: () => schema2,
   useAddressController: () => useAddressController,
   useAddressRepo: () => useAddressRepo,
   useAuthController: () => useAuthController,
@@ -11388,12 +11391,16 @@ __export(src_exports, {
   useFileRepo: () => useFileRepo,
   useFileService: () => useFileService,
   useMemberRepo: () => useMemberRepo,
+  useOrderController: () => useOrderController,
+  useOrderRepo: () => useOrderRepo,
   useOrgController: () => useOrgController,
   useOrgRepo: () => useOrgRepo,
   useOrgService: () => useOrgService,
   usePaymentMethodController: () => usePaymentMethodController,
   usePaymentMethodRepo: () => usePaymentMethodRepo,
   usePaymentMethodService: () => usePaymentMethodService,
+  usePromoCodeController: () => usePromoCodeController,
+  usePromoCodeRepo: () => usePromoCodeRepo,
   useRoleController: () => useRoleController,
   useRoleRepo: () => useRoleRepo,
   useRoleService: () => useRoleService,
@@ -12438,10 +12445,10 @@ var import_utils8 = require("@goweekdays/utils");
 var import_joi2 = __toESM(require("joi"));
 var import_mongodb8 = require("mongodb");
 function MMember(value) {
-  const schema = import_joi2.default.object({
+  const schema3 = import_joi2.default.object({
     _id: import_joi2.default.string().hex().optional().allow("", null),
-    org: import_joi2.default.string().hex().required(),
-    orgName: import_joi2.default.string().required(),
+    org: import_joi2.default.string().hex().optional().allow("", null),
+    orgName: import_joi2.default.string().optional().allow("", null),
     name: import_joi2.default.string().required(),
     user: import_joi2.default.string().hex().required(),
     role: import_joi2.default.string().hex().required(),
@@ -12450,7 +12457,7 @@ function MMember(value) {
     updatedAt: import_joi2.default.string().optional().allow("", null),
     deletedAt: import_joi2.default.string().optional().allow("", null)
   });
-  const { error } = schema.validate(value);
+  const { error } = schema3.validate(value);
   if (error) {
     throw new import_utils8.BadRequestError(error.message);
   }
@@ -12477,8 +12484,8 @@ function MMember(value) {
   }
   return {
     _id: value._id,
-    org: value.org,
-    orgName: value.orgName,
+    org: value.org ?? "",
+    orgName: value.orgName ?? "",
     name: value.name,
     user: value.user,
     role: value.role,
@@ -13520,7 +13527,10 @@ function useRoleRepo() {
   }
   async function createUniqueIndex() {
     try {
-      await collection.createIndex({ name: 1, type: 1 }, { unique: true });
+      await collection.createIndex(
+        { name: 1, type: 1, org: 1 },
+        { unique: true }
+      );
     } catch (error) {
       throw new import_utils14.InternalServerError("Failed to create unique index on role.");
     }
@@ -13534,7 +13544,7 @@ function useRoleRepo() {
       import_utils14.logger.log({ level: "error", message: `${error}` });
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_utils14.BadRequestError("Item role already exists");
+        throw new import_utils14.BadRequestError("Role already exists");
       }
       throw new import_utils14.InternalServerError("Failed to create role.");
     }
@@ -15527,36 +15537,75 @@ function useCommentController() {
 
 // src/models/subscription.model.ts
 var import_utils27 = require("@goweekdays/utils");
+var import_joi11 = __toESM(require("joi"));
 var import_mongodb20 = require("mongodb");
 function MSubscription(value) {
-  if (value._id) {
-    try {
-      value._id = new import_mongodb20.ObjectId(value._id);
-    } catch (error) {
-      throw new import_utils27.BadRequestError("Invalid ID.");
-    }
-  }
-  if (value.user) {
-    try {
-      value.user = new import_mongodb20.ObjectId(value.user);
-    } catch (error) {
-      throw new import_utils27.BadRequestError("Invalid user ID.");
-    }
-  }
-  if (value.org) {
-    try {
-      value.org = new import_mongodb20.ObjectId(value.org);
-    } catch (error) {
-      throw new import_utils27.BadRequestError("Invalid org ID.");
+  const schema3 = import_joi11.default.object({
+    _id: import_joi11.default.string().hex().optional().allow("", null),
+    user: import_joi11.default.string().hex().optional().allow("", null),
+    org: import_joi11.default.string().hex().optional().allow("", null),
+    customerId: import_joi11.default.string().required(),
+    paymentMethodId: import_joi11.default.string().required(),
+    amount: import_joi11.default.number().positive().min(0).required(),
+    currency: import_joi11.default.string().required(),
+    description: import_joi11.default.string().optional().allow("", null),
+    promoCode: import_joi11.default.string().optional().allow("", null),
+    type: import_joi11.default.string().valid("organization", "affiliate").required(),
+    seats: import_joi11.default.number().optional().min(0).allow(null, ""),
+    status: import_joi11.default.string().optional().allow("", null),
+    billingCycle: import_joi11.default.string().valid("monthly", "yearly").required(),
+    // Ensure valid values
+    nextBillingDate: import_joi11.default.date().optional(),
+    lastPaymentStatus: import_joi11.default.string().optional().allow("", null),
+    failedAttempts: import_joi11.default.number().optional().allow("", null),
+    createdAt: import_joi11.default.date().optional(),
+    updatedAt: import_joi11.default.string().optional().allow("", null),
+    deletedAt: import_joi11.default.string().optional().allow("", null)
+  }).custom((value2, helpers) => {
+    if (!value2.user && !value2.org) {
+      return helpers.error("any.invalid", {
+        message: "Either user or org is required."
+      });
     }
-  }
+    return value2;
+  });
+  const { error } = schema3.validate(value);
+  if (error) {
+    throw new import_utils27.BadRequestError(error.details[0].message);
+  }
+  if (value._id)
+    value._id = new import_mongodb20.ObjectId(value._id);
+  if (value.user)
+    value.user = new import_mongodb20.ObjectId(value.user);
+  if (value.org)
+    value.org = new import_mongodb20.ObjectId(value.org);
+  const createdAt = value.createdAt ? new Date(value.createdAt) : /* @__PURE__ */ new Date();
+  const nextBillingDate = new Date(createdAt);
+  if (value.billingCycle === "monthly") {
+    nextBillingDate.setMonth(nextBillingDate.getMonth() + 1);
+  } else if (value.billingCycle === "yearly") {
+    nextBillingDate.setFullYear(nextBillingDate.getFullYear() + 1);
+  }
+  nextBillingDate.setDate(nextBillingDate.getDate() + 1);
   return {
     _id: value._id,
     user: value.user ?? "",
     org: value.org ?? "",
-    subscriptionId: value.subscriptionId,
+    customerId: value.customerId,
+    paymentMethodId: value.paymentMethodId,
+    amount: value.amount,
+    currency: value.currency,
+    description: value.description ?? "",
+    type: value.type,
+    promoCode: value.promoCode ?? "",
+    seats: value.seats ?? 0,
     status: "active",
-    createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    billingCycle: value.billingCycle,
+    nextBillingDate: nextBillingDate.toISOString(),
+    // Fixed nextBillingDate logic
+    lastPaymentStatus: value.lastPaymentStatus ?? "success",
+    failedAttempts: value.failedAttempts ?? 0,
+    createdAt: createdAt.toISOString(),
     updatedAt: value.updatedAt ?? "",
     deletedAt: value.deletedAt ?? ""
   };
@@ -15565,6 +15614,7 @@ function MSubscription(value) {
 // src/repositories/subscription.repository.ts
 var import_utils28 = require("@goweekdays/utils");
 var import_mongodb21 = require("mongodb");
+var import_joi12 = __toESM(require("joi"));
 function useSubscriptionRepo() {
   const db = import_utils28.useAtlas.getDb();
   if (!db) {
@@ -15584,7 +15634,10 @@ function useSubscriptionRepo() {
   }
   async function createUniqueIndex() {
     try {
-      await collection.createIndex({ user: 1, status: 1 }, { unique: true });
+      await collection.createIndex(
+        { user: 1, org: 1, status: 1 },
+        { unique: true }
+      );
     } catch (error) {
       throw new import_utils28.BadRequestError(
         "Failed to create unique index on subscription."
@@ -15597,6 +15650,7 @@ function useSubscriptionRepo() {
       const res = await collection.insertOne(value, { session });
       return res.insertedId;
     } catch (error) {
+      console.log(error);
       throw new import_utils28.BadRequestError("Failed to create subscription.");
     }
   }
@@ -15624,6 +15678,36 @@ function useSubscriptionRepo() {
       throw new import_utils28.BadRequestError("Failed to get subscription by ID.");
     }
   }
+  async function getByAffiliateUserId(user) {
+    try {
+      user = new import_mongodb21.ObjectId(user);
+    } catch (error) {
+      throw new import_utils28.BadRequestError("Invalid user ID.");
+    }
+    try {
+      return await collection.findOne({
+        user,
+        type: "affiliate"
+      });
+    } catch (error) {
+      throw new import_utils28.BadRequestError("Failed to get subscription by ID.");
+    }
+  }
+  async function getByOrgId(org) {
+    try {
+      org = new import_mongodb21.ObjectId(org);
+    } catch (error) {
+      throw new import_utils28.BadRequestError("Invalid org ID.");
+    }
+    try {
+      return await collection.findOne({
+        org,
+        type: "organization"
+      });
+    } catch (error) {
+      throw new import_utils28.BadRequestError("Failed to get subscription by ID.");
+    }
+  }
   async function getBySubscriptionId(subscriptionId) {
     try {
       return await collection.findOne({ subscriptionId });
@@ -15673,6 +15757,112 @@ function useSubscriptionRepo() {
       throw new import_utils28.BadRequestError("Failed to update subscription status.");
     }
   }
+  async function getDueSubscriptions(BATCH_SIZE = 100) {
+    const today = /* @__PURE__ */ new Date();
+    today.setUTCHours(0, 0, 0, 0);
+    try {
+      return await collection.find({
+        status: "active",
+        nextBillingDate: { $lte: today }
+      }).sort({ nextBillingDate: 1 }).limit(BATCH_SIZE).toArray();
+    } catch (error) {
+      throw new import_utils28.BadRequestError("Failed to get due subscriptions.");
+    }
+  }
+  async function getFailedSubscriptions(BATCH_SIZE = 100, maxAttempts = 3) {
+    try {
+      return await collection.find({
+        lastPaymentStatus: "failed",
+        failedAttempts: { $lt: maxAttempts }
+      }).limit(BATCH_SIZE).toArray();
+    } catch (error) {
+      throw new import_utils28.BadRequestError("Failed to get failed subscriptions.");
+    }
+  }
+  async function processSuccessfulPayment(value, session) {
+    const schema3 = import_joi12.default.object({
+      _id: import_joi12.default.string().hex().required(),
+      nextBillingDate: import_joi12.default.date().required()
+    });
+    const { error } = schema3.validate(value);
+    if (error) {
+      throw new import_utils28.BadRequestError(error.message);
+    }
+    try {
+      value._id = new import_mongodb21.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_utils28.BadRequestError("Invalid ID.");
+    }
+    const date = value.nextBillingDate;
+    try {
+      await collection.updateOne(
+        { _id: value._id },
+        {
+          $set: {
+            nextBillingDate: new Date(
+              new Date(date).setMonth(new Date(date).getMonth() + 1)
+            ).toISOString(),
+            lastPaymentStatus: "success",
+            failedAttempts: 0
+          }
+        },
+        { session }
+      );
+      return "Successfully updated subscription.";
+    } catch (_) {
+      throw new import_utils28.BadRequestError("Failed to update subscription.");
+    }
+  }
+  async function markSubscriptionAsFailed({ _id, failed } = {}, session) {
+    const schema3 = import_joi12.default.object({
+      _id: import_joi12.default.string().hex().required()
+    });
+    const { error } = schema3.validate({ _id });
+    if (error) {
+      throw new import_utils28.BadRequestError(error.message);
+    }
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils28.BadRequestError("Invalid ID.");
+    }
+    const updateOptions = {
+      $inc: { failedAttempts: 1 }
+    };
+    if (failed) {
+      updateOptions.$set = { lastPaymentStatus: "failed" };
+    }
+    try {
+      return await collection.updateOne({ _id }, updateOptions, { session });
+    } catch (error2) {
+      throw new import_utils28.BadRequestError("Failed to update subscription.");
+    }
+  }
+  async function markSubscriptionAsCanceled(_id, session) {
+    const schema3 = import_joi12.default.object({
+      _id: import_joi12.default.string().hex().required()
+    });
+    const { error } = schema3.validate({ _id });
+    if (error) {
+      throw new import_utils28.BadRequestError(error.message);
+    }
+    try {
+      _id = new import_mongodb21.ObjectId(_id);
+    } catch (error2) {
+      throw new import_utils28.BadRequestError("Invalid ID.");
+    }
+    try {
+      return await collection.updateOne(
+        { _id },
+        {
+          $set: { status: "canceled" }
+        },
+        { session }
+      );
+    } catch (error2) {
+      throw new import_utils28.BadRequestError("Failed to update subscription.");
+    }
+  }
   return {
     createIndex,
     createUniqueIndex,
@@ -15681,12 +15871,19 @@ function useSubscriptionRepo() {
     getBySubscriptionId,
     getByUserId,
     getSubscriptions,
-    updateStatus
+    updateStatus,
+    getByOrgId,
+    getByAffiliateUserId,
+    getDueSubscriptions,
+    getFailedSubscriptions,
+    processSuccessfulPayment,
+    markSubscriptionAsFailed,
+    markSubscriptionAsCanceled
   };
 }
 
 // src/services/subscription.service.ts
-var import_utils62 = require("@goweekdays/utils");
+var import_utils64 = require("@goweekdays/utils");
 
 // node_modules/axios/lib/helpers/bind.js
 function bind(fn, thisArg) {
@@ -18560,7 +18757,7 @@ validators.spelling = function spelling(correctSpelling) {
     return true;
   };
 };
-function assertOptions(options, schema, allowUnknown) {
+function assertOptions(options, schema3, allowUnknown) {
   if (typeof options !== "object") {
     throw new AxiosError_default("options must be an object", AxiosError_default.ERR_BAD_OPTION_VALUE);
   }
@@ -18568,7 +18765,7 @@ function assertOptions(options, schema, allowUnknown) {
   let i = keys.length;
   while (i-- > 0) {
     const opt = keys[i];
-    const validator = schema[opt];
+    const validator = schema3[opt];
     if (validator) {
       const value = options[opt];
       const result = value === void 0 || validator(value, opt, options);
@@ -18992,6 +19189,7 @@ var {
 // src/services/xendit.service.ts
 var import_utils55 = require("@goweekdays/utils");
 var import_mongodb22 = require("mongodb");
+var import_joi13 = __toESM(require("joi"));
 function useXenditService() {
   const basicAuth = Buffer.from(`${XENDIT_SECRET_KEY}:`).toString("base64");
   const axios2 = axios_default.create({
@@ -19150,7 +19348,8 @@ function useXenditService() {
     amount = 0,
     paymentMethod = "",
     description = "",
-    interval = "MONTH"
+    interval = "MONTH",
+    seats = 1
   } = {}) {
     try {
       const res = await axios2.post("/recurring/plans", {
@@ -19183,7 +19382,9 @@ function useXenditService() {
         },
         failed_cycle_action: "STOP",
         immediate_action_type: "FULL_AMOUNT",
-        metadata: null,
+        metadata: {
+          seats
+        },
         description
       });
       return res.data;
@@ -19210,6 +19411,52 @@ function useXenditService() {
       throw new import_utils55.BadRequestError("Failed to get subscription status.");
     }
   }
+  async function getSubscription(id) {
+    try {
+      const res = await axios2.get(`/recurring/plans/${id}`);
+      return res.data;
+    } catch (error) {
+      throw new import_utils55.BadRequestError("Failed to get subscription.");
+    }
+  }
+  async function getSubscriptionCycles(id) {
+    try {
+      const res = await axios2.get(`/recurring/plans/${id}/cycles`);
+      return res.data;
+    } catch (error) {
+      throw new import_utils55.BadRequestError("Failed to get subscription cycles.");
+    }
+  }
+  async function pay(value) {
+    try {
+      const schema3 = import_joi13.default.object({
+        amount: import_joi13.default.number().positive().min(0).required(),
+        currency: import_joi13.default.string().required(),
+        payment_method_id: import_joi13.default.string().required(),
+        customer_id: import_joi13.default.string().required(),
+        description: import_joi13.default.string().optional().allow("", null),
+        metadata: import_joi13.default.object().optional()
+      });
+      const { error } = schema3.validate(value);
+      if (error) {
+        throw new import_utils55.BadRequestError(error.message);
+      }
+      const res = await axios2.post("/payment_requests", {
+        amount: value.amount,
+        currency: value.currency,
+        payment_method_id: value.payment_method_id,
+        customer_id: value.customer_id,
+        description: value.description ?? "",
+        metadata: value.metadata ?? {}
+      });
+      return res.data;
+    } catch (error) {
+      if (error instanceof import_utils55.AppError) {
+        throw error;
+      }
+      throw new import_utils55.BadRequestError("Failed to initiate payment request.");
+    }
+  }
   return {
     createCustomer,
     linkPaymentMethodEWallet,
@@ -19218,7 +19465,10 @@ function useXenditService() {
     linkPaymentMethodCard,
     eWalletSubsequentPayment,
     checkSubscriptionStatus,
-    cancelSubscription
+    cancelSubscription,
+    getSubscription,
+    getSubscriptionCycles,
+    pay
   };
 }
 
@@ -19253,7 +19503,8 @@ function MPaymentMethod(value) {
     paymentId: value.paymentId ?? "",
     customerId: value.customerId ?? "",
     number: value.number,
-    expiry: value.expiry ?? "",
+    month_expiry: value.month_expiry ?? "",
+    year_expiry: value.year_expiry ?? "",
     cvv: value.cvv ?? "",
     status: value.status ?? "active",
     createdAt: value.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
@@ -19405,23 +19656,23 @@ var import_utils59 = require("@goweekdays/utils");
 
 // src/models/organization.model.ts
 var import_utils58 = require("@goweekdays/utils");
-var import_joi11 = __toESM(require("joi"));
+var import_joi14 = __toESM(require("joi"));
 var import_mongodb25 = require("mongodb");
 function MOrg(value) {
-  const schema = import_joi11.default.object({
-    _id: import_joi11.default.string().hex().optional().allow("", null),
-    name: import_joi11.default.string().required(),
-    email: import_joi11.default.string().email().required(),
-    contact: import_joi11.default.string().required(),
-    type: import_joi11.default.string().required(),
-    busInst: import_joi11.default.string().optional().allow("", null),
-    description: import_joi11.default.string().optional().allow("", null),
-    status: import_joi11.default.string().optional().allow("", null),
-    createdAt: import_joi11.default.string().optional().allow("", null),
-    updatedAt: import_joi11.default.string().optional().allow("", null),
-    deletedAt: import_joi11.default.string().optional().allow("", null)
+  const schema3 = import_joi14.default.object({
+    _id: import_joi14.default.string().hex().optional().allow("", null),
+    name: import_joi14.default.string().required(),
+    email: import_joi14.default.string().email().required(),
+    contact: import_joi14.default.string().required(),
+    type: import_joi14.default.string().required(),
+    busInst: import_joi14.default.string().optional().allow("", null),
+    description: import_joi14.default.string().optional().allow("", null),
+    status: import_joi14.default.string().optional().allow("", null),
+    createdAt: import_joi14.default.string().optional().allow("", null),
+    updatedAt: import_joi14.default.string().optional().allow("", null),
+    deletedAt: import_joi14.default.string().optional().allow("", null)
   });
-  const { error } = schema.validate(value);
+  const { error } = schema3.validate(value);
   if (error) {
     throw new import_utils58.BadRequestError(error.message);
   }
@@ -19710,27 +19961,198 @@ function useAddressRepo() {
   };
 }
 
+// src/repositories/order.repository.ts
+var import_utils63 = require("@goweekdays/utils");
+
+// src/models/order.model.ts
+var import_mongodb29 = require("mongodb");
+
+// src/validations/order.schema.ts
+var import_joi15 = __toESM(require("joi"));
+var schema = import_joi15.default.object({
+  _id: import_joi15.default.string().hex().optional().allow("", null),
+  payment: import_joi15.default.string().required(),
+  user: import_joi15.default.string().hex().required(),
+  org: import_joi15.default.string().hex().optional().allow("", null),
+  type: import_joi15.default.string().required(),
+  amount: import_joi15.default.number().positive().min(0).required(),
+  currency: import_joi15.default.string().required(),
+  description: import_joi15.default.string().optional().allow("", null),
+  metadata: import_joi15.default.object({
+    subscriptionId: import_joi15.default.string().hex().optional().allow("", null),
+    cycle: import_joi15.default.number().optional().allow("", null),
+    seats: import_joi15.default.number().optional().allow("", null),
+    promoCode: import_joi15.default.string().optional().allow("", null)
+  }).optional().allow("", null),
+  status: import_joi15.default.string().optional().allow("", null),
+  createdAt: import_joi15.default.string().optional().allow("", null),
+  updatedAt: import_joi15.default.string().optional().allow("", null),
+  deletedAt: import_joi15.default.string().optional().allow("", null)
+});
+
+// src/models/order.model.ts
+var import_utils62 = require("@goweekdays/utils");
+function MOrder(value) {
+  const { error } = schema.validate(value);
+  if (error) {
+    throw new import_utils62.BadRequestError(error.message);
+  }
+  if (value._id) {
+    try {
+      value._id = new import_mongodb29.ObjectId(value._id);
+    } catch (error2) {
+      throw new import_utils62.BadRequestError("Invalid ID.");
+    }
+  }
+  if (value.user) {
+    try {
+      value.user = new import_mongodb29.ObjectId(value.user);
+    } catch (error2) {
+      throw new import_utils62.BadRequestError("Invalid user ID.");
+    }
+  }
+  if (value.org) {
+    try {
+      value.org = new import_mongodb29.ObjectId(value.org);
+    } catch (error2) {
+      throw new import_utils62.BadRequestError("Invalid org ID.");
+    }
+  }
+  if (value.metadata?.subscriptionId) {
+    try {
+      value.metadata.subscriptionId = new import_mongodb29.ObjectId(
+        value.metadata.subscriptionId
+      );
+    } catch (error2) {
+      throw new import_utils62.BadRequestError("Invalid subscription ID.");
+    }
+  }
+  return {
+    _id: value._id,
+    payment: value.payment,
+    user: value.user ?? "",
+    org: value.org ?? "",
+    type: value.type,
+    amount: value.amount,
+    currency: value.currency,
+    description: value.description ?? "",
+    metadata: value.metadata ?? {},
+    status: value.status ?? "succeeded",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/repositories/order.repository.ts
+var import_mongodb30 = require("mongodb");
+function useOrderRepo() {
+  const db = import_utils63.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils63.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("orders");
+  function createIndex() {
+    try {
+      collection.createIndexes([
+        { key: { "metadata.subscriptionId": 1 } },
+        { key: { status: 1 } },
+        { key: { type: 1 } }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index for promo code.");
+    }
+  }
+  function add(value, session) {
+    try {
+      value = MOrder(value);
+      collection.insertOne(value, { session });
+    } catch (error) {
+      import_utils63.logger.log({ level: "error", message: `${error}` });
+      if (error instanceof import_utils63.AppError) {
+        throw error;
+      }
+      throw new import_utils63.InternalServerError("Internal server error.");
+    }
+  }
+  async function getOrders({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active",
+    type = "",
+    id = ""
+  } = {}) {
+    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 (id) {
+      try {
+        query["metadata.subscriptionId"] = new import_mongodb30.ObjectId(id);
+      } catch (error) {
+        throw new import_utils63.BadRequestError("Invalid subscription ID.");
+      }
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      return (0, import_utils63.paginate)(items, page, limit, length);
+    } catch (error) {
+      import_utils63.logger.log({ level: "error", message: `${error}` });
+      throw new import_utils63.InternalServerError("Internal server error.");
+    }
+  }
+  return {
+    createIndex,
+    add,
+    getOrders
+  };
+}
+
 // src/services/subscription.service.ts
 function useSubscriptionService() {
-  const { getByUserId: _getByUserId, add } = useSubscriptionRepo();
+  const {
+    getByUserId: _getByUserId,
+    add,
+    getByOrgId: _getByOrgId,
+    getDueSubscriptions,
+    processSuccessfulPayment,
+    markSubscriptionAsFailed,
+    getFailedSubscriptions,
+    markSubscriptionAsCanceled
+  } = useSubscriptionRepo();
   const { getUserById: _getUserByUserId, updateUserFieldById } = useUserRepo();
-  const { initSubscription, checkSubscriptionStatus } = useXenditService();
-  const { add: addPaymentMethod, getByPaymentMethodId } = usePaymentMethodRepo();
+  const {
+    checkSubscriptionStatus,
+    getSubscription,
+    getSubscriptionCycles,
+    pay
+  } = useXenditService();
+  const { add: addPaymentMethod } = usePaymentMethodRepo();
   const { add: addOrg } = useOrgRepo();
   const { add: addAddress } = useAddressRepo();
   const { addRole } = useRoleRepo();
   const { add: addMember } = useMemberRepo();
+  const { add: addOrder } = useOrderRepo();
   async function createOrgSubscription(value) {
-    const session = import_utils62.useAtlas.getClient()?.startSession();
+    const session = import_utils64.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _user = await _getUserByUserId(value.user);
       if (!_user) {
-        throw new import_utils62.BadRequestError("User not found.");
-      }
-      const payment = await getByPaymentMethodId(value.payment_method_id);
-      if (!payment) {
-        throw new import_utils62.BadRequestError("Payment method not found.");
+        throw new import_utils64.BadRequestError("User not found.");
       }
       const org = await addOrg(value.organization, session);
       const role = await addRole(
@@ -19759,64 +20181,118 @@ function useSubscriptionService() {
           session
         );
       }
-      payment.user = "";
-      payment.org = org;
-      delete payment._id;
-      await addPaymentMethod(payment, session);
-      value.billingAddress.org = org;
-      await addAddress(value.billingAddress, session);
-      const subscription = await initSubscription({
-        customer: value.customer_id,
-        paymentMethod: value.payment_method_id,
-        amount: value.amount,
-        description: "GoWeekdays Organization Monthly Subscription."
-      });
-      await add(
+      await addPaymentMethod(
         {
           org,
-          subscriptionId: subscription.id
+          paymentId: value.payment_method_id,
+          customerId: value.customer_id,
+          type: value.payment_method_type,
+          name: value.payment_method_channel,
+          number: value.payment_method_number,
+          month_expiry: value.payment_method_expiry_month,
+          year_expiry: value.payment_method_expiry_year,
+          cvv: value.payment_method_cvv
         },
         session
       );
-      await session?.commitTransaction();
-      return "Subscription created successfully.";
-    } catch (error) {
+      value.billingAddress.org = org;
+      await addAddress(value.billingAddress, session);
+      const description = "GoWeekdays Organization Monthly Subscription.";
+      const subscription = await add(
+        {
+          org: org.toString(),
+          customerId: value.customer_id,
+          paymentMethodId: value.payment_method_id,
+          amount: value.amount,
+          currency: value.currency,
+          type: "organization",
+          description,
+          seats: value.seats,
+          billingCycle: "monthly"
+        },
+        session
+      );
+      const payment = await pay({
+        customer_id: value.customer_id,
+        payment_method_id: value.payment_method_id,
+        amount: value.amount,
+        currency: value.currency,
+        description
+      });
+      await addOrder(
+        {
+          payment: payment.id,
+          user: value.user,
+          org: org.toString(),
+          type: "organization",
+          amount: value.amount,
+          currency: value.currency,
+          description,
+          metadata: { subscriptionId: subscription.toString() }
+        },
+        session
+      );
+      await session?.commitTransaction();
+      return {
+        message: "Subscription created successfully.",
+        data: { org: org.toString() }
+      };
+    } catch (error) {
       await session?.abortTransaction();
       throw error;
     } finally {
       session?.endSession();
     }
   }
-  async function createAffiliateSubscription({
-    user = "",
-    amount = 0,
-    payment_method_id = "",
-    customer_id = ""
-  } = {}) {
-    const session = import_utils62.useAtlas.getClient()?.startSession();
+  async function createAffiliateSubscription(value) {
+    const session = import_utils64.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
-      const _user = await _getUserByUserId(user);
+      const _user = await _getUserByUserId(value.user);
       if (!_user) {
-        throw new import_utils62.BadRequestError("User not found.");
+        throw new import_utils64.BadRequestError("User not found.");
       }
-      const subscription = await initSubscription({
-        customer: customer_id,
-        paymentMethod: payment_method_id,
-        amount,
-        description: "GoWeekdays Affiliate Annual Subscription.",
-        interval: "YEAR"
-      });
-      await add(
+      await addAddress(value.billingAddress, session);
+      const description = "GoWeekdays affiliate yearly Subscription.";
+      const subscription = await add(
         {
-          user,
-          subscriptionId: subscription.id
+          user: value.user,
+          customerId: value.customer_id,
+          paymentMethodId: value.payment_method_id,
+          amount: value.amount,
+          currency: value.currency,
+          type: "affiliate",
+          description,
+          billingCycle: "yearly"
+        },
+        session
+      );
+      let payment = {};
+      if (value.amount) {
+        payment = await pay({
+          customer_id: value.customer_id,
+          payment_method_id: value.payment_method_id,
+          amount: value.amount,
+          currency: value.currency,
+          description
+        });
+      }
+      await addOrder(
+        {
+          payment: payment.id,
+          user: value.user,
+          type: "affiliate",
+          amount: value.amount,
+          currency: value.currency,
+          description,
+          metadata: { subscriptionId: subscription.toString() }
         },
         session
       );
       await session?.commitTransaction();
       return "Subscription created successfully.";
     } catch (error) {
+      console.log(error);
       await session?.abortTransaction();
       throw error;
     } finally {
@@ -19827,9 +20303,10 @@ function useSubscriptionService() {
     try {
       const subscription = await _getByUserId(id);
       if (!subscription) {
-        throw new import_utils62.BadRequestError("Subscription not found.");
+        throw new import_utils64.BadRequestError("Subscription not found.");
       }
-      return subscription;
+      const customerSubscription = await getSubscription(id);
+      return customerSubscription;
     } catch (error) {
       throw error;
     }
@@ -19842,57 +20319,204 @@ function useSubscriptionService() {
       );
       return status;
     } catch (error) {
-      throw new import_utils62.BadRequestError("Failed to fetch subscription status");
+      throw new import_utils64.BadRequestError("Failed to fetch subscription status");
     }
   }
+  async function processSubscriptions(batchSize = 100) {
+    while (true) {
+      const subscriptions = await getDueSubscriptions(batchSize);
+      if (subscriptions.length === 0) {
+        import_utils64.logger.log({
+          level: "info",
+          message: "No more subscriptions to process."
+        });
+        break;
+      }
+      await Promise.allSettled(
+        subscriptions.map(async (sub) => {
+          const session = import_utils64.useAtlas.getClient()?.startSession();
+          session?.startTransaction();
+          try {
+            const payment = await pay({
+              customer_id: sub.customerId,
+              payment_method_id: sub.paymentMethodId,
+              amount: sub.amount,
+              currency: sub.currency,
+              description: "GoWeekdays Monthly Subscription"
+            });
+            await addOrder(
+              {
+                payment: payment.id,
+                user: sub.user,
+                org: sub.org,
+                type: "organization",
+                amount: sub.amount,
+                currency: sub.currency,
+                description: "GoWeekdays Monthly Subscription",
+                metadata: { subscriptionId: sub._id }
+              },
+              session
+            );
+            await processSuccessfulPayment(
+              { _id: sub._id, nextBillingDate: sub.nextBillingDate },
+              session
+            );
+            await session?.commitTransaction();
+            import_utils64.logger.log({
+              level: "info",
+              message: `Processed subscription ${sub._id} successfully.`
+            });
+          } catch (error) {
+            await session?.abortTransaction();
+            import_utils64.logger.log({
+              level: "error",
+              message: `Failed to process ${sub._id}: ${error}`
+            });
+            await markSubscriptionAsFailed({
+              _id: String(sub._id),
+              failed: true
+            });
+          } finally {
+            session?.endSession();
+          }
+        })
+      );
+      import_utils64.logger.log({
+        level: "info",
+        message: "Processed a batch of subscriptions."
+      });
+    }
+  }
+  async function retryFailedPayments(batchSize = 100) {
+    let hasMore = true;
+    while (hasMore) {
+      const failedSubs = await getFailedSubscriptions(batchSize);
+      if (failedSubs.length === 0) {
+        hasMore = false;
+        break;
+      }
+      await Promise.allSettled(
+        failedSubs.map(async (sub) => {
+          const session = import_utils64.useAtlas.getClient()?.startSession();
+          session?.startTransaction();
+          try {
+            const payment = await pay({
+              customer_id: sub.customerId,
+              payment_method_id: sub.paymentMethodId,
+              amount: sub.amount,
+              currency: sub.currency,
+              description: "GoWeekdays Monthly Subscription - Retry"
+            });
+            await addOrder(
+              {
+                payment: payment.id,
+                user: sub.user,
+                org: sub.org,
+                type: "organization",
+                amount: sub.amount,
+                currency: sub.currency,
+                description: "GoWeekdays Monthly Subscription",
+                metadata: { subscriptionId: sub._id }
+              },
+              session
+            );
+            await processSuccessfulPayment(
+              { _id: sub._id, nextBillingDate: sub.nextBillingDate },
+              session
+            );
+            await session?.commitTransaction();
+            import_utils64.logger.log({
+              level: "info",
+              message: `Successfully retried subscription ${sub._id}.`
+            });
+          } catch (error) {
+            await session?.abortTransaction();
+            import_utils64.logger.log({
+              level: "error",
+              message: `Retry failed for ${sub._id}: ${error}`
+            });
+            await markSubscriptionAsFailed({ _id: String(sub._id) });
+            if (sub.failedAttempts && sub.failedAttempts + 1 >= 3) {
+              await markSubscriptionAsCanceled(String(sub._id));
+              import_utils64.logger.log({
+                level: "info",
+                message: `Subscription ${sub._id} canceled after max retry attempts.`
+              });
+            }
+          } finally {
+            session?.endSession();
+          }
+        })
+      );
+      import_utils64.logger.log({
+        level: "info",
+        message: `Processed batch of ${failedSubs.length}.`
+      });
+    }
+    import_utils64.logger.log({ level: "info", message: "All failed payments retried." });
+  }
   return {
     getByUserId,
     getStatusByUser,
     createAffiliateSubscription,
-    createOrgSubscription
+    createOrgSubscription,
+    processSubscriptions,
+    retryFailedPayments
   };
 }
 
 // src/controllers/subscription.controller.ts
-var import_joi13 = __toESM(require("joi"));
-var import_utils63 = require("@goweekdays/utils");
+var import_joi17 = __toESM(require("joi"));
+var import_utils65 = require("@goweekdays/utils");
 
 // src/validations/subscription.schema.ts
-var import_joi12 = __toESM(require("joi"));
+var import_joi16 = __toESM(require("joi"));
 function useSubscriptionSchema() {
-  const schema = import_joi12.default.object({
-    user: import_joi12.default.string().required(),
-    amount: import_joi12.default.number().required(),
-    customer_id: import_joi12.default.string().required(),
-    payment_method_id: import_joi12.default.string().required(),
-    currency: import_joi12.default.string().optional().allow("", null),
-    organization: import_joi12.default.object({
-      name: import_joi12.default.string().required(),
-      description: import_joi12.default.string().optional().allow("", null),
-      type: import_joi12.default.string().allow("personal", "business").required(),
-      email: import_joi12.default.string().email().required(),
-      contact: import_joi12.default.string().required(),
-      busInst: import_joi12.default.string().optional().allow(null, "")
-    }).required(),
-    billingAddress: import_joi12.default.object({
-      type: import_joi12.default.string().required(),
-      country: import_joi12.default.string().required(),
-      address: import_joi12.default.string().required(),
-      continuedAddress: import_joi12.default.string().optional().allow(null, ""),
-      city: import_joi12.default.string().required(),
-      province: import_joi12.default.string().required(),
-      postalCode: import_joi12.default.string().required(),
-      taxId: import_joi12.default.string().optional().allow(null, "")
+  const schema3 = import_joi16.default.object({
+    user: import_joi16.default.string().required().min(0),
+    amount: import_joi16.default.number().required(),
+    customer_id: import_joi16.default.string().required(),
+    payment_method_id: import_joi16.default.string().required(),
+    payment_method_type: import_joi16.default.string().required(),
+    payment_method_number: import_joi16.default.string().required(),
+    payment_method_channel: import_joi16.default.string().required(),
+    payment_method_month_expiry: import_joi16.default.string().optional().allow(null, ""),
+    payment_method_year_expiry: import_joi16.default.string().optional().allow(null, ""),
+    payment_method_cvv: import_joi16.default.string().optional().allow(null, ""),
+    currency: import_joi16.default.string().optional().allow("", null),
+    seats: import_joi16.default.number().optional().min(0).allow(null),
+    organization: import_joi16.default.object({
+      name: import_joi16.default.string().required(),
+      description: import_joi16.default.string().optional().allow("", null),
+      type: import_joi16.default.string().allow("personal", "business").required(),
+      email: import_joi16.default.string().email().required(),
+      contact: import_joi16.default.string().required(),
+      busInst: import_joi16.default.string().optional().allow(null, "")
+    }).optional().allow({}),
+    billingAddress: import_joi16.default.object({
+      type: import_joi16.default.string().required(),
+      country: import_joi16.default.string().required(),
+      address: import_joi16.default.string().required(),
+      continuedAddress: import_joi16.default.string().optional().allow(null, ""),
+      city: import_joi16.default.string().required(),
+      province: import_joi16.default.string().required(),
+      postalCode: import_joi16.default.string().required(),
+      taxId: import_joi16.default.string().optional().allow(null, "")
     }).required()
   });
   return {
-    schema
+    schema: schema3
   };
 }
 
 // src/controllers/subscription.controller.ts
 function useSubscriptionController() {
-  const { add: _add, getSubscriptions: _getSubscriptions } = useSubscriptionRepo();
+  const {
+    add: _add,
+    getSubscriptions: _getSubscriptions,
+    getByAffiliateUserId: _getByAffiliateUserId,
+    getByOrgId: _getByOrgId
+  } = useSubscriptionRepo();
   const {
     getByUserId: _getByUserId,
     getStatusByUser: _getStatusByUser,
@@ -19901,13 +20525,13 @@ function useSubscriptionController() {
   } = useSubscriptionService();
   async function add(req, res, next) {
     const value = req.body;
-    const validation = import_joi13.default.object({
-      user: import_joi13.default.string().required(),
-      subscriptionId: import_joi13.default.string().required()
+    const validation = import_joi17.default.object({
+      user: import_joi17.default.string().required(),
+      subscriptionId: import_joi17.default.string().required()
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils63.BadRequestError(error.message));
+      next(new import_utils65.BadRequestError(error.message));
     }
     try {
       const value2 = req.body;
@@ -19920,10 +20544,10 @@ function useSubscriptionController() {
   }
   async function getByUserId(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi13.default.string().required();
+    const validation = import_joi17.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils63.BadRequestError(error.message));
+      next(new import_utils65.BadRequestError(error.message));
     }
     try {
       const subscription = await _getByUserId(id);
@@ -19933,18 +20557,48 @@ function useSubscriptionController() {
       next(error2);
     }
   }
+  async function getByAffiliateUserId(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi17.default.string().required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+    }
+    try {
+      const subscription = await _getByAffiliateUserId(id);
+      res.json(subscription);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getByOrgId(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi17.default.string().required();
+    const { error } = validation.validate(id);
+    if (error) {
+      next(new import_utils65.BadRequestError(error.message));
+    }
+    try {
+      const subscription = await _getByOrgId(id);
+      res.json(subscription);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   async function getSubscriptions(req, res, next) {
     const status = req.query.status ?? "";
     const search = req.query.search ?? "";
     const page = Number(req.query.page) ?? 1;
-    const validation = import_joi13.default.object({
-      status: import_joi13.default.string().required(),
-      search: import_joi13.default.string().optional().allow("", null),
-      page: import_joi13.default.number().required()
+    const validation = import_joi17.default.object({
+      status: import_joi17.default.string().required(),
+      search: import_joi17.default.string().optional().allow("", null),
+      page: import_joi17.default.number().required()
     });
     const { error } = validation.validate({ status, search, page });
     if (error) {
-      next(new import_utils63.BadRequestError(error.message));
+      next(new import_utils65.BadRequestError(error.message));
     }
     try {
       const subscriptions = await _getSubscriptions({ status, search, page });
@@ -19956,10 +20610,10 @@ function useSubscriptionController() {
   }
   async function getSubscriptionStatus(req, res, next) {
     const id = req.params.id;
-    const validation = import_joi13.default.string().required();
+    const validation = import_joi17.default.string().required();
     const { error } = validation.validate(id);
     if (error) {
-      next(new import_utils63.BadRequestError(error.message));
+      next(new import_utils65.BadRequestError(error.message));
     }
     try {
       const status = await _getStatusByUser(id);
@@ -19969,37 +20623,17 @@ function useSubscriptionController() {
       next(error2);
     }
   }
+  const { schema: subscriptionSchema } = useSubscriptionSchema();
   async function createAffiliateSubscription(req, res, next) {
-    const amount = req.body.amount ?? 0;
-    const payment_method_id = req.body.payment_method_id ?? "";
-    const customer_id = req.body.customer_id ?? "";
-    const currency = req.body.currency ?? "PHP";
-    const user = req.headers["user"];
-    const validation = import_joi13.default.object({
-      user: import_joi13.default.string().required(),
-      amount: import_joi13.default.number().required(),
-      customer_id: import_joi13.default.string().required(),
-      payment_method_id: import_joi13.default.string().required(),
-      currency: import_joi13.default.string().optional().allow("", null)
-    });
-    const { error } = validation.validate({
-      user,
-      amount,
-      customer_id,
-      payment_method_id,
-      currency
-    });
+    const value = req.body;
+    value.user = req.headers["user"];
+    const { error } = subscriptionSchema.validate(value);
     if (error) {
-      next(new import_utils63.BadRequestError(error.message));
+      next(new import_utils65.BadRequestError(error.message));
       return;
     }
     try {
-      const id = await _createAffiliateSubscription({
-        user,
-        amount,
-        customer_id,
-        payment_method_id
-      });
+      const id = await _createAffiliateSubscription(value);
       res.json({ message: "Successfully added subscription.", id });
       return;
     } catch (error2) {
@@ -20008,18 +20642,17 @@ function useSubscriptionController() {
       return;
     }
   }
-  const { schema: subscriptionSchema } = useSubscriptionSchema();
   async function createOrgSubscription(req, res, next) {
     const value = req.body;
     value.user = req.headers["user"];
     const { error } = subscriptionSchema.validate(value);
     if (error) {
-      next(new import_utils63.BadRequestError(error.message));
+      next(new import_utils65.BadRequestError(error.message));
       return;
     }
     try {
-      const id = await _createOrgSubscription(value);
-      res.json({ message: "Successfully added subscription.", id });
+      const _res = await _createOrgSubscription(value);
+      res.json(_res);
       return;
     } catch (error2) {
       next(error2);
@@ -20029,6 +20662,8 @@ function useSubscriptionController() {
   return {
     add,
     getByUserId,
+    getByOrgId,
+    getByAffiliateUserId,
     getSubscriptions,
     getSubscriptionStatus,
     createAffiliateSubscription,
@@ -20037,7 +20672,7 @@ function useSubscriptionController() {
 }
 
 // src/services/payment-method.service.ts
-var import_utils64 = require("@goweekdays/utils");
+var import_utils66 = require("@goweekdays/utils");
 function usePaymentMethodService() {
   const { createCustomer, linkPaymentMethodEWallet, linkPaymentMethodCard } = useXenditService();
   const { getUserById } = useUserRepo();
@@ -20090,7 +20725,7 @@ function usePaymentMethodService() {
     failure_return_url = "",
     cancel_return_url = ""
   } = {}) {
-    const session = import_utils64.useAtlas.getClient()?.startSession();
+    const session = import_utils66.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const customerData = {
@@ -20100,10 +20735,10 @@ function usePaymentMethodService() {
       if (user) {
         const _user = await getUserById(user);
         if (!_user) {
-          throw new import_utils64.BadRequestError("User not found.");
+          throw new import_utils66.BadRequestError("User not found.");
         }
         if (!_user._id) {
-          throw new import_utils64.BadRequestError("Invalid user ID.");
+          throw new import_utils66.BadRequestError("Invalid user ID.");
         }
         customerData.email = _user.email;
         customerData.given_names = _user.firstName;
@@ -20112,7 +20747,7 @@ function usePaymentMethodService() {
       if (org) {
         const _org = await getOrgById(org);
         if (!_org) {
-          throw new import_utils64.BadRequestError("Organization not found.");
+          throw new import_utils66.BadRequestError("Organization not found.");
         }
         customerData.email = _org.email;
         customerData.given_names = _org.name;
@@ -20126,20 +20761,6 @@ function usePaymentMethodService() {
         failure_return_url,
         cancel_return_url
       });
-      await add(
-        {
-          user,
-          org,
-          type,
-          status: "active",
-          paymentId: paymentMethod.id,
-          customerId: customer.id,
-          name: paymentMethod.type,
-          number: mobile_number
-        },
-        session
-      );
-      await session?.commitTransaction();
       return {
         paymentMethod: paymentMethod.id,
         customer: customer.id,
@@ -20164,15 +20785,15 @@ function usePaymentMethodService() {
     cardholder_name = "",
     currency = "PHP"
   } = {}) {
-    const session = import_utils64.useAtlas.getClient()?.startSession();
+    const session = import_utils66.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _user = await getUserById(user);
       if (!_user) {
-        throw new import_utils64.BadRequestError("User not found.");
+        throw new import_utils66.BadRequestError("User not found.");
       }
       if (!_user._id) {
-        throw new import_utils64.BadRequestError("Invalid user ID.");
+        throw new import_utils66.BadRequestError("Invalid user ID.");
       }
       const result = await linkPaymentMethodCard({
         card_number,
@@ -20212,8 +20833,8 @@ function usePaymentMethodService() {
 }
 
 // src/controllers/payment-method.controller.ts
-var import_joi14 = __toESM(require("joi"));
-var import_utils65 = require("@goweekdays/utils");
+var import_joi18 = __toESM(require("joi"));
+var import_utils67 = require("@goweekdays/utils");
 function usePaymentMethodController() {
   const { linkEWallet: _linkEWallet, linkCard: _linkCard } = usePaymentMethodService();
   async function linkEWallet(req, res, next) {
@@ -20224,14 +20845,14 @@ function usePaymentMethodController() {
     const success_return_url = req.body.success_return_url ?? "";
     const failure_return_url = req.body.failure_return_url ?? "";
     const cancel_return_url = req.body.cancel_return_url ?? "";
-    const validation = import_joi14.default.object({
-      user: import_joi14.default.string().hex().optional().allow("", null),
-      org: import_joi14.default.string().hex().optional().allow("", null),
-      mobile_number: import_joi14.default.string().required(),
-      type: import_joi14.default.string().valid("GCASH", "PAYMAYA").required(),
-      success_return_url: import_joi14.default.string().uri().required(),
-      failure_return_url: import_joi14.default.string().uri().required(),
-      cancel_return_url: import_joi14.default.string().uri().required()
+    const validation = import_joi18.default.object({
+      user: import_joi18.default.string().hex().optional().allow("", null),
+      org: import_joi18.default.string().hex().optional().allow("", null),
+      mobile_number: import_joi18.default.string().required(),
+      type: import_joi18.default.string().valid("GCASH", "PAYMAYA").required(),
+      success_return_url: import_joi18.default.string().uri().required(),
+      failure_return_url: import_joi18.default.string().uri().required(),
+      cancel_return_url: import_joi18.default.string().uri().required()
     }).custom((value, helpers) => {
       if (!value.user && !value.org) {
         return helpers.error("any.invalid", {
@@ -20250,7 +20871,7 @@ function usePaymentMethodController() {
       cancel_return_url
     });
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils67.BadRequestError(error.message));
     }
     try {
       const result = await _linkEWallet({
@@ -20279,17 +20900,17 @@ function usePaymentMethodController() {
     const failure_return_url = req.body.failure_return_url ?? "";
     const cardType = req.body.cardType ?? "";
     const user = req.headers["user"] ?? "";
-    const validation = import_joi14.default.object({
-      cardNumber: import_joi14.default.string().required(),
-      expiryMonth: import_joi14.default.string().required(),
-      expiryYear: import_joi14.default.string().required(),
-      cvv: import_joi14.default.string().required(),
-      cardholderName: import_joi14.default.string().required(),
-      currency: import_joi14.default.string().optional().allow("", null),
-      success_return_url: import_joi14.default.string().uri().required(),
-      failure_return_url: import_joi14.default.string().uri().required(),
-      cardType: import_joi14.default.string().required(),
-      user: import_joi14.default.string().hex().required()
+    const validation = import_joi18.default.object({
+      cardNumber: import_joi18.default.string().required(),
+      expiryMonth: import_joi18.default.string().required(),
+      expiryYear: import_joi18.default.string().required(),
+      cvv: import_joi18.default.string().required(),
+      cardholderName: import_joi18.default.string().required(),
+      currency: import_joi18.default.string().optional().allow("", null),
+      success_return_url: import_joi18.default.string().uri().required(),
+      failure_return_url: import_joi18.default.string().uri().required(),
+      cardType: import_joi18.default.string().required(),
+      user: import_joi18.default.string().hex().required()
     });
     const { error } = validation.validate({
       user,
@@ -20304,7 +20925,7 @@ function usePaymentMethodController() {
       failure_return_url
     });
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils67.BadRequestError(error.message));
     }
     try {
       const result = await _linkCard({
@@ -20328,12 +20949,12 @@ function usePaymentMethodController() {
   const { getByUser: _getByUser, getByOrg: _getByOrg } = usePaymentMethodRepo();
   async function getByUser(req, res, next) {
     const user = req.params.user ?? "";
-    const validation = import_joi14.default.object({
-      user: import_joi14.default.string().hex().required()
+    const validation = import_joi18.default.object({
+      user: import_joi18.default.string().hex().required()
     });
     const { error } = validation.validate({ user });
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils67.BadRequestError(error.message));
     }
     try {
       const result = await _getByUser(user);
@@ -20344,12 +20965,12 @@ function usePaymentMethodController() {
   }
   async function getByOrg(req, res, next) {
     const org = req.params.org ?? "";
-    const validation = import_joi14.default.object({
-      org: import_joi14.default.string().hex().required()
+    const validation = import_joi18.default.object({
+      org: import_joi18.default.string().hex().required()
     });
     const { error } = validation.validate({ org });
     if (error) {
-      next(new import_utils65.BadRequestError(error.message));
+      next(new import_utils67.BadRequestError(error.message));
     }
     try {
       const result = await _getByOrg(org);
@@ -20367,27 +20988,27 @@ function usePaymentMethodController() {
 }
 
 // src/controllers/address.controller.ts
-var import_utils66 = require("@goweekdays/utils");
-var import_joi15 = __toESM(require("joi"));
+var import_utils68 = require("@goweekdays/utils");
+var import_joi19 = __toESM(require("joi"));
 function useAddressController() {
   const { add: _add, getByUserId: _getByUserId } = useAddressRepo();
   async function add(req, res, next) {
     const value = req.body;
-    const validation = import_joi15.default.object({
-      type: import_joi15.default.string().required(),
-      user: import_joi15.default.string().hex().optional().allow("", null),
-      org: import_joi15.default.string().hex().optional().allow("", null),
-      country: import_joi15.default.string().required(),
-      address: import_joi15.default.string().required(),
-      continuedAddress: import_joi15.default.string().optional().allow("", null),
-      city: import_joi15.default.string().required(),
-      province: import_joi15.default.string().required(),
-      postalCode: import_joi15.default.string().required(),
-      taxId: import_joi15.default.string().optional().allow("", null)
+    const validation = import_joi19.default.object({
+      type: import_joi19.default.string().required(),
+      user: import_joi19.default.string().hex().optional().allow("", null),
+      org: import_joi19.default.string().hex().optional().allow("", null),
+      country: import_joi19.default.string().required(),
+      address: import_joi19.default.string().required(),
+      continuedAddress: import_joi19.default.string().optional().allow("", null),
+      city: import_joi19.default.string().required(),
+      province: import_joi19.default.string().required(),
+      postalCode: import_joi19.default.string().required(),
+      taxId: import_joi19.default.string().optional().allow("", null)
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils66.BadRequestError(error.message));
+      next(new import_utils68.BadRequestError(error.message));
     }
     try {
       const value2 = req.body;
@@ -20400,15 +21021,15 @@ function useAddressController() {
   }
   async function getByUserId(req, res, next) {
     const user = req.params.user;
-    const validation = import_joi15.default.string().hex().required();
+    const validation = import_joi19.default.string().hex().required();
     const { error } = validation.validate(user);
     if (error) {
-      next(new import_utils66.BadRequestError(error.message));
+      next(new import_utils68.BadRequestError(error.message));
     }
     try {
       const address = await _getByUserId(user);
       if (!address) {
-        next(new import_utils66.NotFoundError("Address not found."));
+        next(new import_utils68.NotFoundError("Address not found."));
         return;
       }
       res.json(address);
@@ -20424,19 +21045,19 @@ function useAddressController() {
 }
 
 // src/services/organization.service.ts
-var import_utils67 = require("@goweekdays/utils");
+var import_utils69 = require("@goweekdays/utils");
 function useOrgService() {
   const { add: addOrg } = useOrgRepo();
   const { addRole } = useRoleRepo();
   const { add: addMember } = useMemberRepo();
   const { getUserById } = useUserRepo();
   async function createOrg({ user = "", name = "", description = "" } = {}) {
-    const session = import_utils67.useAtlas.getClient()?.startSession();
+    const session = import_utils69.useAtlas.getClient()?.startSession();
     session?.startTransaction();
     try {
       const _user = await getUserById(user);
       if (!_user) {
-        throw new import_utils67.NotFoundError("User not found.");
+        throw new import_utils69.NotFoundError("User not found.");
       }
       const org = await addOrg(
         {
@@ -20479,25 +21100,25 @@ function useOrgService() {
 }
 
 // src/controllers/organization.controller.ts
-var import_utils68 = require("@goweekdays/utils");
-var import_joi16 = __toESM(require("joi"));
+var import_utils70 = require("@goweekdays/utils");
+var import_joi20 = __toESM(require("joi"));
 function useOrgController() {
   const { createOrg: _createOrg } = useOrgService();
   const { getByUserId: _getByUserId } = useMemberRepo();
   const { getByName: _getByName } = useOrgRepo();
   async function createOrg(req, res, next) {
     const value = req.body;
-    const validation = import_joi16.default.object({
-      name: import_joi16.default.string().required(),
-      type: import_joi16.default.string().required(),
-      email: import_joi16.default.string().email().required(),
-      contact: import_joi16.default.string().required(),
-      description: import_joi16.default.string().required(),
-      user: import_joi16.default.string().hex().required()
+    const validation = import_joi20.default.object({
+      name: import_joi20.default.string().required(),
+      type: import_joi20.default.string().required(),
+      email: import_joi20.default.string().email().required(),
+      contact: import_joi20.default.string().required(),
+      description: import_joi20.default.string().required(),
+      user: import_joi20.default.string().hex().required()
     });
     const { error } = validation.validate(value);
     if (error) {
-      next(new import_utils68.BadRequestError(error.message));
+      next(new import_utils70.BadRequestError(error.message));
       return;
     }
     try {
@@ -20515,23 +21136,23 @@ function useOrgController() {
     const user = req.headers["user"];
     const isPageNumber = isFinite(page);
     if (!isPageNumber) {
-      next(new import_utils68.BadRequestError("Invalid page number."));
+      next(new import_utils70.BadRequestError("Invalid page number."));
       return;
     }
     const isLimitNumber = isFinite(limit);
     if (!isLimitNumber) {
-      next(new import_utils68.BadRequestError("Invalid limit number."));
+      next(new import_utils70.BadRequestError("Invalid limit number."));
       return;
     }
-    const validation = import_joi16.default.object({
-      user: import_joi16.default.string().hex().required(),
-      page: import_joi16.default.number().min(1).optional().allow("", null),
-      limit: import_joi16.default.number().min(1).optional().allow("", null),
-      search: import_joi16.default.string().optional().allow("", null)
+    const validation = import_joi20.default.object({
+      user: import_joi20.default.string().hex().required(),
+      page: import_joi20.default.number().min(1).optional().allow("", null),
+      limit: import_joi20.default.number().min(1).optional().allow("", null),
+      search: import_joi20.default.string().optional().allow("", null)
     });
     const { error } = validation.validate({ user, page, limit, search });
     if (error) {
-      next(new import_utils68.BadRequestError(error.message));
+      next(new import_utils70.BadRequestError(error.message));
       return;
     }
     try {
@@ -20544,12 +21165,12 @@ function useOrgController() {
   }
   async function getByName(req, res, next) {
     const name = req.params.name;
-    const validation = import_joi16.default.object({
-      name: import_joi16.default.string().required()
+    const validation = import_joi20.default.object({
+      name: import_joi20.default.string().required()
     });
     const { error } = validation.validate({ name });
     if (error) {
-      next(new import_utils68.BadRequestError(error.message));
+      next(new import_utils70.BadRequestError(error.message));
       return;
     }
     try {
@@ -20566,6 +21187,274 @@ function useOrgController() {
     getByName
   };
 }
+
+// src/validations/promo-code.schema.ts
+var import_joi21 = __toESM(require("joi"));
+var promoTypeSchema = import_joi21.default.string().valid("tiered", "fixed").required();
+var promoTierSchema = import_joi21.default.object({
+  min: import_joi21.default.number().integer().min(1).required(),
+  max: import_joi21.default.number().integer().min(import_joi21.default.ref("min")).allow(0).required(),
+  price: import_joi21.default.number().positive().required()
+});
+var schema2 = import_joi21.default.object({
+  code: import_joi21.default.string().trim().uppercase().required(),
+  description: import_joi21.default.string().trim().optional(),
+  type: promoTypeSchema,
+  tiers: import_joi21.default.alternatives().conditional("type", {
+    is: "tiered",
+    then: import_joi21.default.array().items(promoTierSchema).min(1).required(),
+    otherwise: import_joi21.default.forbidden()
+  }),
+  fixed_rate: import_joi21.default.alternatives().conditional("type", {
+    is: "fixed",
+    then: import_joi21.default.number().required().min(0),
+    otherwise: import_joi21.default.number().integer().allow(0)
+  }),
+  expiresAt: import_joi21.default.string().optional().allow(null, "")
+});
+
+// src/models/promo-code.model.ts
+var import_utils71 = require("@goweekdays/utils");
+function MPromoCode(data) {
+  const { error } = schema2.validate(data);
+  if (error) {
+    throw new import_utils71.BadRequestError(error.message);
+  }
+  return {
+    _id: data._id,
+    code: data.code,
+    description: data.description ?? "",
+    type: data.type,
+    tiers: data.tiers ?? [],
+    fixed_rate: data.fixed_rate ?? 0,
+    appliesTo: data.appliesTo ?? "",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    expiresAt: data.expiresAt ?? "",
+    assignedTo: data.assignedTo,
+    status: data.status ?? "active"
+  };
+}
+
+// src/repositories/promo-code.repository.ts
+var import_utils72 = require("@goweekdays/utils");
+var import_joi22 = __toESM(require("joi"));
+function usePromoCodeRepo() {
+  const db = import_utils72.useAtlas.getDb();
+  if (!db) {
+    throw new import_utils72.InternalServerError("Unable to connect to server.");
+  }
+  const collection = db.collection("promo-codes");
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { code: 1 } },
+        { key: { type: 1 } }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index for promo code.");
+    }
+  }
+  async function createUniqueIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { code: 1, type: 1 }, unique: true }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create unique index for promo code.");
+    }
+  }
+  async function add(value) {
+    try {
+      value = MPromoCode(value);
+      await collection.insertOne(value);
+    } catch (error) {
+      import_utils72.logger.log({ level: "error", message: `${error}` });
+      const isDuplicated = error.message.includes("duplicate");
+      if (isDuplicated) {
+        throw new import_utils72.BadRequestError("Promo code already exists.");
+      }
+      throw new import_utils72.InternalServerError("Internal server error.");
+    }
+  }
+  async function getByCode(code) {
+    const schema3 = import_joi22.default.object({
+      code: import_joi22.default.string().trim().required()
+    });
+    const { error } = schema3.validate({ code });
+    if (error) {
+      throw new import_utils72.BadRequestError(error.message);
+    }
+    try {
+      return await collection.findOne({ code });
+    } catch (error2) {
+      throw new import_utils72.InternalServerError("Internal server error.");
+    }
+  }
+  async function getPromoCodes({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active",
+    type = ""
+  } = {}) {
+    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;
+    }
+    try {
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const length = await collection.countDocuments(query);
+      return (0, import_utils72.paginate)(items, page, limit, length);
+    } catch (error) {
+      import_utils72.logger.log({ level: "error", message: `${error}` });
+      throw new import_utils72.InternalServerError("Internal server error.");
+    }
+  }
+  return {
+    createIndex,
+    createUniqueIndex,
+    add,
+    getByCode,
+    getPromoCodes
+  };
+}
+
+// src/controllers/promo-code.controller.ts
+var import_utils73 = require("@goweekdays/utils");
+var import_joi23 = __toESM(require("joi"));
+function usePromoCodeController() {
+  const {
+    add: _add,
+    getByCode: _getByCode,
+    getPromoCodes: _getPromoCodes
+  } = usePromoCodeRepo();
+  async function add(req, res, next) {
+    const data = req.body;
+    const { error } = schema2.validate(data);
+    if (error) {
+      next(new import_utils73.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _add(data);
+      res.json({ message: "Successfully added promo code." });
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_utils73.AppError) {
+        next(error2);
+      } else {
+        next(new import_utils73.InternalServerError(error2));
+      }
+    }
+  }
+  async function getByCode(req, res, next) {
+    const code = req.params.code;
+    const validation = import_joi23.default.string().required();
+    const { error } = validation.validate(code);
+    if (error) {
+      next(new import_utils73.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const promoCode = await _getByCode(code);
+      res.json({ promoCode });
+      return;
+    } catch (error2) {
+      if (error2 instanceof import_utils73.AppError) {
+        next(error2);
+      } else {
+        next(new import_utils73.InternalServerError(error2));
+      }
+    }
+  }
+  async function getPromoCodes(req, res, next) {
+    const page = req.query.page ? Number(req.query.page) : 1;
+    const limit = req.query.limit ? Number(req.query.limit) : 10;
+    const search = req.query.search;
+    const status = req.query.status;
+    const validation = import_joi23.default.object({
+      page: import_joi23.default.number().required(),
+      limit: import_joi23.default.number().integer().optional().min(10).max(100),
+      search: import_joi23.default.string().optional().allow(""),
+      status: import_joi23.default.string().required()
+    });
+    const { error } = validation.validate({ page, limit, search, status });
+    if (error) {
+      next(new import_utils73.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const promoCodes = await _getPromoCodes({
+        page,
+        limit,
+        search,
+        status
+      });
+      res.json(promoCodes);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getByCode,
+    getPromoCodes
+  };
+}
+
+// src/controllers/order.controller.ts
+var import_utils74 = require("@goweekdays/utils");
+var import_joi24 = __toESM(require("joi"));
+function useOrderController() {
+  const { getOrders: _getOrders } = useOrderRepo();
+  async function getOrders(req, res, next) {
+    const page = req.query.page ?? 1;
+    const limit = req.query.limit ?? 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "succeeded";
+    const id = req.query.id ?? "";
+    const validation = import_joi24.default.object({
+      page: import_joi24.default.number().required(),
+      limit: import_joi24.default.number().required().min(10),
+      search: import_joi24.default.string().optional().allow("", null),
+      status: import_joi24.default.string().optional().allow("", null),
+      id: import_joi24.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate({ page, limit, search, status, id });
+    if (error) {
+      next(new import_utils74.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const orders = await _getOrders({
+        page: parseInt(page),
+        limit: parseInt(limit),
+        search,
+        status,
+        id
+      });
+      res.json(orders);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getOrders
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCESS_TOKEN_EXPIRY,
@@ -20589,8 +21478,10 @@ function useOrgController() {
   MMember,
   MONGO_DB,
   MONGO_URI,
+  MOrder,
   MOrg,
   MPaymentMethod,
+  MPromoCode,
   MRole,
   MSubscription,
   MToken,
@@ -20618,6 +21509,7 @@ function useOrgController() {
   XENDIT_BASE_URL,
   XENDIT_SECRET_KEY,
   isDev,
+  schema,
   useAddressController,
   useAddressRepo,
   useAuthController,
@@ -20635,12 +21527,16 @@ function useOrgController() {
   useFileRepo,
   useFileService,
   useMemberRepo,
+  useOrderController,
+  useOrderRepo,
   useOrgController,
   useOrgRepo,
   useOrgService,
   usePaymentMethodController,
   usePaymentMethodRepo,
   usePaymentMethodService,
+  usePromoCodeController,
+  usePromoCodeRepo,
   useRoleController,
   useRoleRepo,
   useRoleService,