@7365admin1/core 3.17.0 → 3.19.0

package/dist/index.js

@@ -12489,7 +12489,8 @@ function useVerificationService() {
     email,
     orgId,
     siteId,
-    siteName
+    siteName,
+    inviteType
   }) {
     const schema2 = import_joi11.default.object({
       email: import_joi11.default.string().email().lowercase().required(),
@@ -12526,11 +12527,11 @@ function useVerificationService() {
     };
     try {
       const org = await getOrgById(orgId);
-      if (org) {
-        value.type = "service-provider-create-org" /* SERVICE_PROVIDER_CREATE_ORG */;
+      if (inviteType === "organization-invite") {
+        value.type = "service-provider-invite" /* SERVICE_PROVIDER_INVITE */;
         subject = "Service Provider Organization Invite" /* _SERVICE_PROVIDER_ORGANIZATION_INVITE */;
       } else {
-        value.type = "service-provider-invite" /* SERVICE_PROVIDER_INVITE */;
+        value.type = "service-provider-create-org" /* SERVICE_PROVIDER_CREATE_ORG */;
         subject = "Service Provider Invite" /* _SERVICE_PROVIDER_INVITE */;
       }
       const res = await _add(value);
@@ -15100,25 +15101,47 @@ function useVerificationController() {
       email: import_joi16.default.string().email().required(),
       orgId: import_joi16.default.string().hex().required(),
       siteId: import_joi16.default.string().hex().required(),
-      siteName: import_joi16.default.string().required()
+      siteName: import_joi16.default.string().required(),
+      inviteType: import_joi16.default.string().valid("create-org", "organization-invite").required()
     });
     const { error } = validation.validate(payload);
     if (error) {
-      import_node_server_utils32.logger.log({ level: "error", message: `controller - ${error.message}` });
+      import_node_server_utils32.logger.log({
+        level: "error",
+        message: `controller - ${error.message}`
+      });
       next(new import_node_server_utils32.BadRequestError(`Invalid input: ${error.message}`));
       return;
     }
+    const {
+      email,
+      orgId,
+      siteId,
+      siteName,
+      inviteType
+    } = payload;
     try {
-      await _createServiceProviderInvite(payload);
+      await _createServiceProviderInvite({
+        email,
+        orgId,
+        siteId,
+        siteName,
+        inviteType
+      });
       const cookieOptions = {
         domain: DOMAIN,
         secure: true,
         maxAge: 4 * 60 * 60 * 1e3
       };
-      res.cookie("service-provider-email", payload.email, cookieOptions).json({ message: "Successfully invited service provider." });
+      res.cookie("service-provider-email", email, cookieOptions).json({
+        message: "Successfully invited service provider."
+      });
       return;
     } catch (error2) {
-      import_node_server_utils32.logger.log({ level: "error", message: `controller - ${error2.message}` });
+      import_node_server_utils32.logger.log({
+        level: "error",
+        message: `controller - ${error2.message}`
+      });
       next(error2);
       return;
     }
@@ -15477,418 +15500,67 @@ function useFileController() {
 }
 
 // src/controllers/organization.controller.ts
-var import_node_server_utils35 = require("@7365admin1/node-server-utils");
-var import_joi18 = __toESM(require("joi"));
-function useOrgController() {
-  const { getOrgsByMembership } = useMemberRepo();
-  const {
-    getByName: _getByName,
-    getById: _getById,
-    getByEmail: _getByEmail,
-    getAll: _getAll,
-    add: _add,
-    update: _update,
-    getOrgsByEmail: _getOrgsByEmail,
-    getAdminOrgForResident: _getAdminOrgForResident,
-    completeOnboardingById: _completeOnboardingById
-  } = useOrgRepo();
-  async function add(req, res, next) {
-    const validation = import_joi18.default.object({
-      name: import_joi18.default.string().required(),
-      type: import_joi18.default.string().required(),
-      nature: import_joi18.default.string().valid(...allowedNatures).required(),
-      email: import_joi18.default.string().email().optional().allow("", null),
-      contact: import_joi18.default.string().optional().allow("", null),
-      terms: import_joi18.default.string().optional().allow("", null),
-      policies: import_joi18.default.string().optional().allow("", null)
-    });
-    const { error } = validation.validate(req.body);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    try {
-      await _add(req.body);
-      res.status(201).json({ message: "Successfully created organization." });
-      return;
-    } catch (error2) {
-      import_node_server_utils35.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getAll(req, res, next) {
-    const validation = import_joi18.default.object({
-      search: import_joi18.default.string().optional().allow("", null),
-      page: import_joi18.default.number().integer().min(1).allow("", null).default(1),
-      limit: import_joi18.default.number().integer().min(1).max(100).allow("", null).default(10),
-      nature: import_joi18.default.string().valid(...allowedNatures).optional().allow("", null),
-      sort: import_joi18.default.string().optional().allow("", null)
-    });
-    const query = { ...req.query };
-    const { error } = validation.validate(query);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    const search = req.query.search ?? "";
-    const page = parseInt(req.query.page ?? "1");
-    const limit = parseInt(req.query.limit ?? "10");
-    const nature = req.query.nature ?? "";
-    try {
-      const data = await _getAll({
-        search,
-        page,
-        limit,
-        nature
-      });
-      res.json(data);
-      return;
-    } catch (error2) {
-      import_node_server_utils35.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function addOnboardingOrg(req, res, next) {
-    const validation = import_joi18.default.object({
-      name: import_joi18.default.string().required(),
-      type: import_joi18.default.string().required(),
-      nature: import_joi18.default.string().valid(...allowedNatures).required(),
-      email: import_joi18.default.string().email().optional().allow("", null),
-      contact: import_joi18.default.string().optional().allow("", null)
-    });
-    const { error } = validation.validate(req.body);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const _id = await _add(req.body);
-      const data = await _getById(_id);
-      res.status(201).json({
-        message: "Successfully created organization.",
-        data
-      });
-      return;
-    } catch (error2) {
-      import_node_server_utils35.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getOrgsByUserId(req, res, next) {
-    const validation = import_joi18.default.object({
-      search: import_joi18.default.string().optional().allow("", null),
-      page: import_joi18.default.number().integer().min(1).allow("", null).default(1),
-      limit: import_joi18.default.number().integer().min(1).max(100).allow("", null).default(10),
-      user: import_joi18.default.string().hex().required(),
-      type: import_joi18.default.string().optional().allow("", null)
-    });
-    const query = { ...req.query };
-    query.user = req.params.user;
-    const { error } = validation.validate(query);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    const search = req.query.search ?? "";
-    const page = parseInt(req.query.page ?? "1");
-    const limit = parseInt(req.query.limit ?? "10");
-    const user = req.params.user;
-    const type = req.query.type ?? "";
-    try {
-      const data = await getOrgsByMembership({
-        search,
-        page,
-        limit,
-        user,
-        type
-      });
-      res.json(data);
-      return;
-    } catch (error2) {
-      import_node_server_utils35.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getByName(req, res, next) {
-    const validation = import_joi18.default.string().required();
-    const name = req.params.name;
-    const { error } = validation.validate(name);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const data = await _getByName(name);
-      res.json(data);
-      return;
-    } catch (error2) {
-      next(error2);
-      return;
-    }
-  }
-  async function getById(req, res, next) {
-    const validation = import_joi18.default.string().hex().required();
-    const _id = req.params.id;
-    const { error } = validation.validate(_id);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const data = await _getById(_id);
-      res.json(data);
-      return;
-    } catch (error2) {
-      import_node_server_utils35.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getByEmail(req, res, next) {
-    const validation = import_joi18.default.string().required();
-    const email = req.params.email;
-    const { error } = validation.validate(email);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const data = await _getByEmail(email);
-      if (!data) {
-        next(new import_node_server_utils35.NotFoundError("Organization not found."));
-        return;
-      }
-      res.json(data);
-      return;
-    } catch (error2) {
-      next(error2);
-      return;
-    }
-  }
-  async function getOrgsByEmail(req, res, next) {
-    const validation = import_joi18.default.object({
-      email: import_joi18.default.string().email().required()
-    });
-    const query = {
-      email: req.params.email
-    };
-    const { error } = validation.validate(query);
-    if (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    const email = req.params.email;
-    try {
-      const data = await _getOrgsByEmail(email);
-      res.json(data);
-      return;
-    } catch (error2) {
-      import_node_server_utils35.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function update(req, res, next) {
-    const validation = import_joi18.default.object({
-      name: import_joi18.default.string().optional(),
-      type: import_joi18.default.string().optional(),
-      nature: import_joi18.default.string().valid(...allowedNatures).optional(),
-      email: import_joi18.default.string().email().allow("", null).optional(),
-      contact: import_joi18.default.string().allow("", null).optional(),
-      terms: import_joi18.default.string().optional().allow("", null),
-      policies: import_joi18.default.string().optional().allow("", null)
-    });
-    const { error } = validation.validate(req.body);
-    if (error) {
-      next(new import_node_server_utils35.BadRequestError(error.message));
-      return;
-    }
-    const id = req.params.id;
-    try {
-      await _update(id, req.body);
-      const data = await _getById(id);
-      res.json({
-        message: "Organization updated successfully",
-        data
-      });
-    } catch (err) {
-      next(err);
-    }
-  }
-  async function getAdminOrgForResident(_req, res, next) {
-    try {
-      const data = await _getAdminOrgForResident();
-      res.status(200).json(data);
-    } catch (error) {
-      import_node_server_utils35.logger.log({ level: "error", message: error.message });
-      next(error);
-    }
-  }
-  return {
-    add,
-    addOnboardingOrg,
-    getAll,
-    getOrgsByUserId,
-    getByName,
-    getById,
-    getByEmail,
-    update,
-    getOrgsByEmail,
-    getAdminOrgForResident
-  };
-}
+var import_node_server_utils37 = require("@7365admin1/node-server-utils");
+var import_joi20 = __toESM(require("joi"));
 
-// src/controllers/organization-v2.controller.ts
-var import_joi19 = __toESM(require("joi"));
+// src/repositories/subscription.repo.ts
 var import_node_server_utils36 = require("@7365admin1/node-server-utils");
-function useOrgControllerV2() {
-  const { getAll: _getAll, getOrganizationsWithSubscription: _getOrganizationsWithSubscription } = useOrgRepo();
-  async function getAll(req, res, next) {
-    const validation = import_joi19.default.object({
-      search: import_joi19.default.string().optional().allow("", null),
-      page: import_joi19.default.number().integer().min(1).allow("", null).default(1),
-      limit: import_joi19.default.number().integer().min(1).max(100).allow("", null).default(10),
-      nature: import_joi19.default.string().valid(...allowedNatures).optional().allow("", null),
-      status: import_joi19.default.string().trim().valid("active", "suspended", "deleted").optional().empty("").default("active")
-    });
-    const query = { ...req.query };
-    const { error, value } = validation.validate(query, {
-      convert: true,
-      stripUnknown: true
-    });
-    if (error) {
-      import_node_server_utils36.logger.log({ level: "error", message: error.message });
-      next(new import_node_server_utils36.BadRequestError(error.message));
-      return;
-    }
-    const search = value.search ?? "";
-    const page = typeof value.page === "number" ? value.page : parseInt(String(value.page ?? "1"), 10);
-    const limit = typeof value.limit === "number" ? value.limit : parseInt(String(value.limit ?? "10"), 10);
-    const nature = value.nature ?? "";
-    const status = value.status;
-    try {
-      const data = await _getAll({
-        search,
-        page,
-        limit,
-        nature,
-        status
-      });
-      res.json(data);
-      return;
-    } catch (error2) {
-      import_node_server_utils36.logger.log({ level: "error", message: error2.message });
-      next(error2);
-      return;
-    }
-  }
-  async function getOrganizationsWithSubscription(req, res, next) {
-    const validation = import_joi19.default.object({
-      search: import_joi19.default.string().optional().allow("", null),
-      page: import_joi19.default.number().integer().min(1).default(1),
-      limit: import_joi19.default.number().integer().min(1).max(100).default(10),
-      status: import_joi19.default.string().trim().valid("active", "suspended", "deleted").default("active"),
-      type: import_joi19.default.string().optional().allow("", null),
-      billingCycle: import_joi19.default.string().optional().allow("", null)
-    });
-    const { error, value } = validation.validate(
-      req.query,
-      {
-        convert: true,
-        stripUnknown: true
-      }
-    );
-    if (error) {
-      next(new import_node_server_utils36.BadRequestError(error.message));
-      return;
-    }
-    try {
-      const data = await _getOrganizationsWithSubscription({
-        search: value.search ?? "",
-        page: value.page ?? 1,
-        limit: value.limit ?? 10,
-        status: value.status ?? "active",
-        type: value.type ?? "",
-        billingCycle: value.billingCycle ?? ""
-      });
-      res.json(data);
-    } catch (error2) {
-      next(error2);
-    }
-  }
-  return {
-    getAll,
-    getOrganizationsWithSubscription
-  };
-}
 
 // src/models/subscription.model.ts
-var import_node_server_utils37 = require("@7365admin1/node-server-utils");
-var import_joi20 = __toESM(require("joi"));
+var import_node_server_utils35 = require("@7365admin1/node-server-utils");
+var import_joi18 = __toESM(require("joi"));
 var import_mongodb22 = require("mongodb");
 var SubscriptionType = /* @__PURE__ */ ((SubscriptionType2) => {
   SubscriptionType2["ORGANIZATION"] = "organization";
   SubscriptionType2["AFFILIATE"] = "affiliate";
   return SubscriptionType2;
 })(SubscriptionType || {});
-var schema = import_joi20.default.object({
-  user: import_joi20.default.string().hex().required(),
-  amount: import_joi20.default.number().min(0).required(),
-  payment_method_card_number: import_joi20.default.string().optional().allow("", null),
-  payment_method_cardholder_name: import_joi20.default.string().optional().allow("", null),
-  payment_method_expiry_month: import_joi20.default.string().optional().allow("", null),
-  payment_method_expiry_year: import_joi20.default.string().optional().allow("", null),
-  payment_method_cvv: import_joi20.default.string().optional().allow("", null),
-  payment_method_type: import_joi20.default.string().optional().allow("", null),
-  currency: import_joi20.default.string().optional().allow("", null),
-  seats: import_joi20.default.number().optional().min(0).allow(null),
+var schema = import_joi18.default.object({
+  user: import_joi18.default.string().hex().required(),
+  amount: import_joi18.default.number().min(0).required(),
+  payment_method_card_number: import_joi18.default.string().optional().allow("", null),
+  payment_method_cardholder_name: import_joi18.default.string().optional().allow("", null),
+  payment_method_expiry_month: import_joi18.default.string().optional().allow("", null),
+  payment_method_expiry_year: import_joi18.default.string().optional().allow("", null),
+  payment_method_cvv: import_joi18.default.string().optional().allow("", null),
+  payment_method_type: import_joi18.default.string().optional().allow("", null),
+  currency: import_joi18.default.string().optional().allow("", null),
+  seats: import_joi18.default.number().optional().min(0).allow(null),
   organization: orgSchema.optional().allow({}),
-  billingAddress: import_joi20.default.object({
-    type: import_joi20.default.string().required(),
-    country: import_joi20.default.string().required(),
-    address: import_joi20.default.string().required(),
-    continuedAddress: import_joi20.default.string().optional().allow("", null),
-    city: import_joi20.default.string().required(),
-    province: import_joi20.default.string().optional().allow("", null),
-    postalCode: import_joi20.default.string().required(),
-    taxId: import_joi20.default.string().optional().allow("", null)
+  billingAddress: import_joi18.default.object({
+    type: import_joi18.default.string().required(),
+    country: import_joi18.default.string().required(),
+    address: import_joi18.default.string().required(),
+    continuedAddress: import_joi18.default.string().optional().allow("", null),
+    city: import_joi18.default.string().required(),
+    province: import_joi18.default.string().optional().allow("", null),
+    postalCode: import_joi18.default.string().required(),
+    taxId: import_joi18.default.string().optional().allow("", null)
   }).required(),
-  promoCode: import_joi20.default.string().optional().allow("", null)
+  promoCode: import_joi18.default.string().optional().allow("", null)
 });
 function MSubscription(value) {
-  const schema2 = import_joi20.default.object({
-    _id: import_joi20.default.string().hex().optional().allow("", null),
-    user: import_joi20.default.string().hex().optional().allow("", null),
-    org: import_joi20.default.string().hex().optional().allow("", null),
-    amount: import_joi20.default.number().min(0).required(),
-    currency: import_joi20.default.string().required(),
-    description: import_joi20.default.string().optional().allow("", null),
-    promoCode: import_joi20.default.string().optional().allow("", null),
-    type: import_joi20.default.string().valid(...Object.values(SubscriptionType)).optional().allow(null, ""),
-    paidSeats: import_joi20.default.number().optional().min(0).allow("", null),
-    currentSeats: import_joi20.default.number().optional().min(0).allow("", null),
-    maxSeats: import_joi20.default.number().optional().min(0).allow("", null),
-    status: import_joi20.default.string().optional().allow("", null),
-    billingCycle: import_joi20.default.string().valid("monthly", "yearly").required(),
+  const schema2 = import_joi18.default.object({
+    _id: import_joi18.default.string().hex().optional().allow("", null),
+    user: import_joi18.default.string().hex().optional().allow("", null),
+    org: import_joi18.default.string().hex().optional().allow("", null),
+    amount: import_joi18.default.number().min(0).required(),
+    currency: import_joi18.default.string().required(),
+    description: import_joi18.default.string().optional().allow("", null),
+    promoCode: import_joi18.default.string().optional().allow("", null),
+    type: import_joi18.default.string().valid(...Object.values(SubscriptionType)).optional().allow(null, ""),
+    paidSeats: import_joi18.default.number().optional().min(0).allow("", null),
+    currentSeats: import_joi18.default.number().optional().min(0).allow("", null),
+    maxSeats: import_joi18.default.number().optional().min(0).allow("", null),
+    status: import_joi18.default.string().optional().allow("", null),
+    billingCycle: import_joi18.default.string().valid("monthly", "yearly").required(),
     // Ensure valid values
-    nextBillingDate: import_joi20.default.date().optional(),
-    lastPaymentStatus: import_joi20.default.string().optional().allow("", null),
-    failedAttempts: import_joi20.default.number().optional().allow("", null),
-    createdAt: import_joi20.default.date().optional(),
-    updatedAt: import_joi20.default.string().optional().allow("", null),
-    deletedAt: import_joi20.default.string().optional().allow("", null)
+    nextBillingDate: import_joi18.default.date().optional(),
+    lastPaymentStatus: import_joi18.default.string().optional().allow("", null),
+    failedAttempts: import_joi18.default.number().optional().allow("", null),
+    createdAt: import_joi18.default.date().optional(),
+    updatedAt: import_joi18.default.string().optional().allow("", null),
+    deletedAt: import_joi18.default.string().optional().allow("", null)
   }).custom((value2, helpers) => {
     if (!value2.user && !value2.org) {
       return helpers.error("any.invalid", {
@@ -15899,7 +15571,7 @@ function MSubscription(value) {
   });
   const { error } = schema2.validate(value);
   if (error) {
-    throw new import_node_server_utils37.BadRequestError(error.details[0].message);
+    throw new import_node_server_utils35.BadRequestError(error.details[0].message);
   }
   if (value._id)
     value._id = new import_mongodb22.ObjectId(value._id);
@@ -15939,13 +15611,12 @@ function MSubscription(value) {
 }
 
 // src/repositories/subscription.repo.ts
-var import_node_server_utils38 = require("@7365admin1/node-server-utils");
 var import_mongodb23 = require("mongodb");
-var import_joi21 = __toESM(require("joi"));
+var import_joi19 = __toESM(require("joi"));
 function useSubscriptionRepo() {
-  const db = import_node_server_utils38.useAtlas.getDb();
+  const db = import_node_server_utils36.useAtlas.getDb();
   if (!db) {
-    throw new import_node_server_utils38.BadRequestError("Unable to connect to server.");
+    throw new import_node_server_utils36.BadRequestError("Unable to connect to server.");
   }
   const namespace_collection = "subscriptions";
   const collection = db.collection(namespace_collection);
@@ -15960,7 +15631,7 @@ function useSubscriptionRepo() {
         { key: { failedAttempts: 1 } }
       ]);
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to create index on subscription.");
+      throw new import_node_server_utils36.BadRequestError("Failed to create index on subscription.");
     }
   }
   async function createUniqueIndex() {
@@ -15970,96 +15641,96 @@ function useSubscriptionRepo() {
         { unique: true }
       );
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError(
+      throw new import_node_server_utils36.BadRequestError(
         "Failed to create unique index on subscription."
       );
     }
   }
-  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils38.useCache)(namespace_collection);
+  const { delNamespace, setCache, getCache, delCache } = (0, import_node_server_utils36.useCache)(namespace_collection);
   async function add(value, session) {
     try {
       value = MSubscription(value);
       const res = await collection.insertOne(value, { session });
       delNamespace().then(() => {
-        import_node_server_utils38.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
+        import_node_server_utils36.logger.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(
+        import_node_server_utils36.logger.error(
           `Failed to clear cache for namespace: ${namespace_collection}`,
           err
         );
       });
       return res.insertedId;
     } catch (error) {
-      import_node_server_utils38.logger.log({ level: "error", message: `${error}` });
+      import_node_server_utils36.logger.log({ level: "error", message: `${error}` });
       const isDuplicated = error.message.includes("duplicate");
       if (isDuplicated) {
-        throw new import_node_server_utils38.BadRequestError("Subscription already exists.");
+        throw new import_node_server_utils36.BadRequestError("Subscription already exists.");
       }
-      throw new import_node_server_utils38.BadRequestError("Failed to create subscription.");
+      throw new import_node_server_utils36.BadRequestError("Failed to create subscription.");
     }
   }
   async function getById(_id) {
     try {
       _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     try {
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id });
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
       const data = await collection.findOne({ _id });
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to get subscription by ID.");
+      throw new import_node_server_utils36.BadRequestError("Failed to get subscription by ID.");
     }
   }
   async function getByUserId(user) {
     try {
       user = new import_mongodb23.ObjectId(user);
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Invalid user ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid user ID format.");
     }
     try {
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { user });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { user });
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
       const data = await collection.findOne({ user });
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to get subscription by ID.");
+      throw new import_node_server_utils36.BadRequestError("Failed to get subscription by ID.");
     }
   }
   async function getByAffiliateUserId(user) {
     try {
       user = new import_mongodb23.ObjectId(user);
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Invalid user ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid user ID format.");
     }
     try {
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, {
         user,
         type: "affiliate"
       });
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
       const data = await collection.findOne({
@@ -16067,29 +15738,29 @@ function useSubscriptionRepo() {
         type: "affiliate"
       });
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to get subscription by ID.");
+      throw new import_node_server_utils36.BadRequestError("Failed to get subscription by ID.");
     }
   }
   async function getByOrgId(org) {
     try {
       org = new import_mongodb23.ObjectId(org);
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Invalid org ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid org ID format.");
     }
     try {
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, {
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, {
         org,
         type: "organization"
       });
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
       const data = await collection.findOne({
@@ -16097,32 +15768,32 @@ function useSubscriptionRepo() {
         type: "organization"
       });
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to get subscription by ID.");
+      throw new import_node_server_utils36.BadRequestError("Failed to get subscription by ID.");
     }
   }
   async function getBySubscriptionId(subscriptionId) {
     try {
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { subscriptionId });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { subscriptionId });
       const cachedData = await getCache(cacheKey);
       if (cachedData) {
-        import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
         return cachedData;
       }
       const data = await collection.findOne({ subscriptionId });
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError(
+      throw new import_node_server_utils36.BadRequestError(
         "Failed to get subscription by subscription ID."
       );
     }
@@ -16143,10 +15814,10 @@ function useSubscriptionRepo() {
       query.$text = { $search: search };
       cacheOptions.search = search;
     }
-    const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -16157,15 +15828,15 @@ function useSubscriptionRepo() {
         { $limit: limit }
       ]).toArray();
       const length = await collection.countDocuments(query);
-      const data = (0, import_node_server_utils38.paginate)(items, page, limit, length);
+      const data = (0, import_node_server_utils36.paginate)(items, page, limit, length);
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      import_node_server_utils38.logger.log({ level: "error", message: `${error}` });
+      import_node_server_utils36.logger.log({ level: "error", message: `${error}` });
       throw error;
     }
   }
@@ -16173,19 +15844,19 @@ function useSubscriptionRepo() {
     try {
       _id = new import_mongodb23.ObjectId(_id);
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     try {
       await collection.updateOne({ _id }, { $set: { status } });
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id });
       delCache(cacheKey).then(() => {
-        import_node_server_utils38.logger.info(`Cache deleted for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache deleted for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
       });
       return "Successfully updated subscription status.";
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to update subscription status.");
+      throw new import_node_server_utils36.BadRequestError("Failed to update subscription status.");
     }
   }
   async function getDueSubscriptions(BATCH_SIZE = 100) {
@@ -16209,10 +15880,10 @@ function useSubscriptionRepo() {
         }
       ]
     };
-    const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -16234,13 +15905,13 @@ function useSubscriptionRepo() {
         ]
       }).sort({ nextBillingDate: 1 }).limit(BATCH_SIZE).toArray();
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to get due subscriptions.");
+      throw new import_node_server_utils36.BadRequestError("Failed to get due subscriptions.");
     }
   }
   async function getFailedSubscriptions(BATCH_SIZE = 100) {
@@ -16248,10 +15919,10 @@ function useSubscriptionRepo() {
       lastPaymentStatus: "failed",
       status: "active"
     };
-    const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, cacheOptions);
+    const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, cacheOptions);
     const cachedData = await getCache(cacheKey);
     if (cachedData) {
-      import_node_server_utils38.logger.info(`Cache hit for key: ${cacheKey}`);
+      import_node_server_utils36.logger.info(`Cache hit for key: ${cacheKey}`);
       return cachedData;
     }
     try {
@@ -16260,13 +15931,13 @@ function useSubscriptionRepo() {
         status: "active"
       }).limit(BATCH_SIZE).toArray();
       setCache(cacheKey, data, 15 * 60).then(() => {
-        import_node_server_utils38.logger.info(`Cache set for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache set for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to set cache for key: ${cacheKey}`, err);
       });
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError("Failed to get failed subscriptions.");
+      throw new import_node_server_utils36.BadRequestError("Failed to get failed subscriptions.");
     }
   }
   async function findOrgSubscriptionsForStatusSync() {
@@ -16280,7 +15951,7 @@ function useSubscriptionRepo() {
       ).toArray();
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError(
+      throw new import_node_server_utils36.BadRequestError(
         "Failed to list organization subscriptions for status sync."
       );
     }
@@ -16299,24 +15970,24 @@ function useSubscriptionRepo() {
       ).toArray();
       return data;
     } catch (error) {
-      throw new import_node_server_utils38.BadRequestError(
+      throw new import_node_server_utils36.BadRequestError(
         "Failed to list organization subscriptions with overdue next billing date."
       );
     }
   }
   async function processSuccessfulPayment(value, session) {
-    const schema2 = import_joi21.default.object({
-      _id: import_joi21.default.string().hex().required(),
-      nextBillingDate: import_joi21.default.date().required()
+    const schema2 = import_joi19.default.object({
+      _id: import_joi19.default.string().hex().required(),
+      nextBillingDate: import_joi19.default.date().required()
     });
     const { error } = schema2.validate(value);
     if (error) {
-      throw new import_node_server_utils38.BadRequestError(error.message);
+      throw new import_node_server_utils36.BadRequestError(error.message);
     }
     try {
       value._id = new import_mongodb23.ObjectId(value._id);
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     const date = value.nextBillingDate;
     try {
@@ -16334,31 +16005,31 @@ function useSubscriptionRepo() {
         },
         { session }
       );
-      import_node_server_utils38.logger.info(`${res.modifiedCount} subscription updated.`);
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id: value._id });
+      import_node_server_utils36.logger.info(`${res.modifiedCount} subscription updated.`);
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id: value._id });
       delCache(cacheKey).then(() => {
-        import_node_server_utils38.logger.info(`Cache deleted for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache deleted for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
       });
       return "Successfully updated subscription.";
     } catch (error2) {
-      import_node_server_utils38.logger.error(`${error2}`);
-      throw new import_node_server_utils38.BadRequestError("Failed to update subscription.");
+      import_node_server_utils36.logger.error(`${error2}`);
+      throw new import_node_server_utils36.BadRequestError("Failed to update subscription.");
     }
   }
   async function markSubscriptionAsFailed({ _id, failed }, session) {
-    const schema2 = import_joi21.default.object({
-      _id: import_joi21.default.string().hex().required()
+    const schema2 = import_joi19.default.object({
+      _id: import_joi19.default.string().hex().required()
     });
     const { error } = schema2.validate({ _id });
     if (error) {
-      throw new import_node_server_utils38.BadRequestError(error.message);
+      throw new import_node_server_utils36.BadRequestError(error.message);
     }
     try {
       _id = new import_mongodb23.ObjectId(_id);
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     const updateOptions = {
       $inc: { failedAttempts: 1 }
@@ -16370,29 +16041,29 @@ function useSubscriptionRepo() {
       const result = await collection.updateOne({ _id }, updateOptions, {
         session
       });
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id });
       delCache(cacheKey).then(() => {
-        import_node_server_utils38.logger.info(`Cache deleted for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache deleted for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
       });
       return result;
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Failed to update subscription.");
+      throw new import_node_server_utils36.BadRequestError("Failed to update subscription.");
     }
   }
   async function markSubscriptionAsCanceled(_id, session) {
-    const schema2 = import_joi21.default.object({
-      _id: import_joi21.default.string().hex().required()
+    const schema2 = import_joi19.default.object({
+      _id: import_joi19.default.string().hex().required()
     });
     const { error } = schema2.validate({ _id });
     if (error) {
-      throw new import_node_server_utils38.BadRequestError(error.message);
+      throw new import_node_server_utils36.BadRequestError(error.message);
     }
     try {
       _id = new import_mongodb23.ObjectId(_id);
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     try {
       const result = await collection.updateOne(
@@ -16400,29 +16071,29 @@ function useSubscriptionRepo() {
         { $set: { status: "canceled" } },
         { session }
       );
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id });
       delCache(cacheKey).then(() => {
-        import_node_server_utils38.logger.info(`Cache deleted for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache deleted for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
       });
       return result;
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Failed to update subscription.");
+      throw new import_node_server_utils36.BadRequestError("Failed to update subscription.");
     }
   }
   async function updateStatusById(_id, status, session) {
-    const schema2 = import_joi21.default.object({
-      _id: import_joi21.default.string().hex().required()
+    const schema2 = import_joi19.default.object({
+      _id: import_joi19.default.string().hex().required()
     });
     const { error } = schema2.validate({ _id });
     if (error) {
-      throw new import_node_server_utils38.BadRequestError(error.message);
+      throw new import_node_server_utils36.BadRequestError(error.message);
     }
     try {
       _id = new import_mongodb23.ObjectId(_id);
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     try {
       const result = await collection.updateOne(
@@ -16430,15 +16101,15 @@ function useSubscriptionRepo() {
         { $set: { status } },
         { session }
       );
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id });
       delCache(cacheKey).then(() => {
-        import_node_server_utils38.logger.info(`Cache deleted for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache deleted for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
       });
       return result;
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Failed to update subscription status.");
+      throw new import_node_server_utils36.BadRequestError("Failed to update subscription status.");
     }
   }
   async function updateSeatsById({
@@ -16449,13 +16120,13 @@ function useSubscriptionRepo() {
     amount,
     promoCode
   }, session) {
-    const schema2 = import_joi21.default.object({
-      _id: import_joi21.default.string().hex().required(),
-      currentSeats: import_joi21.default.number().required().min(1),
-      maxSeats: import_joi21.default.number().required().min(0),
-      paidSeats: import_joi21.default.number().optional().min(0),
-      amount: import_joi21.default.number().required().min(0),
-      promoCode: import_joi21.default.string().optional().allow("", null)
+    const schema2 = import_joi19.default.object({
+      _id: import_joi19.default.string().hex().required(),
+      currentSeats: import_joi19.default.number().required().min(1),
+      maxSeats: import_joi19.default.number().required().min(0),
+      paidSeats: import_joi19.default.number().optional().min(0),
+      amount: import_joi19.default.number().required().min(0),
+      promoCode: import_joi19.default.string().optional().allow("", null)
     });
     const { error } = schema2.validate({
       _id,
@@ -16466,12 +16137,12 @@ function useSubscriptionRepo() {
       promoCode
     });
     if (error) {
-      throw new import_node_server_utils38.BadRequestError(error.message);
+      throw new import_node_server_utils36.BadRequestError(error.message);
     }
     try {
       _id = new import_mongodb23.ObjectId(_id);
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     const data = {
       currentSeats,
@@ -16490,33 +16161,33 @@ function useSubscriptionRepo() {
         { $set: data },
         { session }
       );
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id });
       delCache(cacheKey).then(() => {
-        import_node_server_utils38.logger.info(`Cache deleted for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache deleted for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
       });
       return result;
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Failed to update subscription seats.");
+      throw new import_node_server_utils36.BadRequestError("Failed to update subscription seats.");
     }
   }
   async function updateMaxSeatsById({
     _id,
     seats
   }, session) {
-    const schema2 = import_joi21.default.object({
-      _id: import_joi21.default.string().hex().required(),
-      seats: import_joi21.default.number().required().min(1)
+    const schema2 = import_joi19.default.object({
+      _id: import_joi19.default.string().hex().required(),
+      seats: import_joi19.default.number().required().min(1)
     });
     const { error } = schema2.validate({ _id, seats });
     if (error) {
-      throw new import_node_server_utils38.BadRequestError(error.message);
+      throw new import_node_server_utils36.BadRequestError(error.message);
     }
     try {
       _id = new import_mongodb23.ObjectId(_id);
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Invalid subscription ID format.");
+      throw new import_node_server_utils36.BadRequestError("Invalid subscription ID format.");
     }
     try {
       const result = await collection.updateOne(
@@ -16524,15 +16195,15 @@ function useSubscriptionRepo() {
         { $set: { maxSeats: seats } },
         { session }
       );
-      const cacheKey = (0, import_node_server_utils38.makeCacheKey)(namespace_collection, { _id });
+      const cacheKey = (0, import_node_server_utils36.makeCacheKey)(namespace_collection, { _id });
       delCache(cacheKey).then(() => {
-        import_node_server_utils38.logger.info(`Cache deleted for key: ${cacheKey}`);
+        import_node_server_utils36.logger.info(`Cache deleted for key: ${cacheKey}`);
       }).catch((err) => {
-        import_node_server_utils38.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        import_node_server_utils36.logger.error(`Failed to delete cache for key: ${cacheKey}`, err);
       });
       return result;
     } catch (error2) {
-      throw new import_node_server_utils38.BadRequestError("Failed to update subscription paid seats.");
+      throw new import_node_server_utils36.BadRequestError("Failed to update subscription paid seats.");
     }
   }
   return {
@@ -16559,6 +16230,397 @@ function useSubscriptionRepo() {
   };
 }
 
+// src/controllers/organization.controller.ts
+function useOrgController() {
+  const { getOrgsByMembership } = useMemberRepo();
+  const {
+    getByName: _getByName,
+    getById: _getById,
+    getByEmail: _getByEmail,
+    getAll: _getAll,
+    add: _add,
+    update: _update,
+    getOrgsByEmail: _getOrgsByEmail,
+    getAdminOrgForResident: _getAdminOrgForResident,
+    completeOnboardingById: _completeOnboardingById,
+    updateStatusById: _updateStatusById
+  } = useOrgRepo();
+  const {
+    getByOrgId: _getSubscriptionByOrgId,
+    updateStatusById: _updateSubscriptionStatusById
+  } = useSubscriptionRepo();
+  async function add(req, res, next) {
+    const validation = import_joi20.default.object({
+      name: import_joi20.default.string().required(),
+      type: import_joi20.default.string().required(),
+      nature: import_joi20.default.string().valid(...allowedNatures).required(),
+      email: import_joi20.default.string().email().optional().allow("", null),
+      contact: import_joi20.default.string().optional().allow("", null),
+      terms: import_joi20.default.string().optional().allow("", null),
+      policies: import_joi20.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(req.body);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await _add(req.body);
+      res.status(201).json({ message: "Successfully created organization." });
+      return;
+    } catch (error2) {
+      import_node_server_utils37.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getAll(req, res, next) {
+    const validation = import_joi20.default.object({
+      search: import_joi20.default.string().optional().allow("", null),
+      page: import_joi20.default.number().integer().min(1).allow("", null).default(1),
+      limit: import_joi20.default.number().integer().min(1).max(100).allow("", null).default(10),
+      nature: import_joi20.default.string().valid(...allowedNatures).optional().allow("", null),
+      sort: import_joi20.default.string().optional().allow("", null)
+    });
+    const query = { ...req.query };
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    const search = req.query.search ?? "";
+    const page = parseInt(req.query.page ?? "1");
+    const limit = parseInt(req.query.limit ?? "10");
+    const nature = req.query.nature ?? "";
+    try {
+      const data = await _getAll({
+        search,
+        page,
+        limit,
+        nature
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils37.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function addOnboardingOrg(req, res, next) {
+    const validation = import_joi20.default.object({
+      name: import_joi20.default.string().required(),
+      type: import_joi20.default.string().required(),
+      nature: import_joi20.default.string().valid(...allowedNatures).required(),
+      email: import_joi20.default.string().email().optional().allow("", null),
+      contact: import_joi20.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(req.body);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const _id = await _add(req.body);
+      const data = await _getById(_id);
+      res.status(201).json({
+        message: "Successfully created organization.",
+        data
+      });
+      return;
+    } catch (error2) {
+      import_node_server_utils37.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getOrgsByUserId(req, res, next) {
+    const validation = import_joi20.default.object({
+      search: import_joi20.default.string().optional().allow("", null),
+      page: import_joi20.default.number().integer().min(1).allow("", null).default(1),
+      limit: import_joi20.default.number().integer().min(1).max(100).allow("", null).default(10),
+      user: import_joi20.default.string().hex().required(),
+      type: import_joi20.default.string().optional().allow("", null)
+    });
+    const query = { ...req.query };
+    query.user = req.params.user;
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    const search = req.query.search ?? "";
+    const page = parseInt(req.query.page ?? "1");
+    const limit = parseInt(req.query.limit ?? "10");
+    const user = req.params.user;
+    const type = req.query.type ?? "";
+    try {
+      const data = await getOrgsByMembership({
+        search,
+        page,
+        limit,
+        user,
+        type
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils37.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getByName(req, res, next) {
+    const validation = import_joi20.default.string().required();
+    const name = req.params.name;
+    const { error } = validation.validate(name);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getByName(name);
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  async function getById(req, res, next) {
+    const validation = import_joi20.default.string().hex().required();
+    const _id = req.params.id;
+    const { error } = validation.validate(_id);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(_id);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils37.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getByEmail(req, res, next) {
+    const validation = import_joi20.default.string().required();
+    const email = req.params.email;
+    const { error } = validation.validate(email);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getByEmail(email);
+      if (!data) {
+        next(new import_node_server_utils37.NotFoundError("Organization not found."));
+        return;
+      }
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
+  async function getOrgsByEmail(req, res, next) {
+    const validation = import_joi20.default.object({
+      email: import_joi20.default.string().email().required()
+    });
+    const query = {
+      email: req.params.email
+    };
+    const { error } = validation.validate(query);
+    if (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    const email = req.params.email;
+    try {
+      const data = await _getOrgsByEmail(email);
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils37.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function update(req, res, next) {
+    const validation = import_joi20.default.object({
+      name: import_joi20.default.string().optional(),
+      type: import_joi20.default.string().optional(),
+      nature: import_joi20.default.string().valid(...allowedNatures).optional(),
+      email: import_joi20.default.string().email().allow("", null).optional(),
+      contact: import_joi20.default.string().allow("", null).optional(),
+      terms: import_joi20.default.string().optional().allow("", null),
+      policies: import_joi20.default.string().optional().allow("", null)
+    });
+    const { error } = validation.validate(req.body);
+    if (error) {
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    const id = req.params.id;
+    try {
+      await _update(id, req.body);
+      const data = await _getById(id);
+      res.json({
+        message: "Organization updated successfully",
+        data
+      });
+    } catch (err) {
+      next(err);
+    }
+  }
+  async function getAdminOrgForResident(_req, res, next) {
+    try {
+      const data = await _getAdminOrgForResident();
+      res.status(200).json(data);
+    } catch (error) {
+      import_node_server_utils37.logger.log({ level: "error", message: error.message });
+      next(error);
+    }
+  }
+  async function updateStatus(req, res, next) {
+    const validation = import_joi20.default.object({
+      status: import_joi20.default.string().valid("active", "suspended").required()
+    });
+    const { error } = validation.validate(req.body);
+    if (error) {
+      next(new import_node_server_utils37.BadRequestError(error.message));
+      return;
+    }
+    const orgId = req.params.id;
+    const { status } = req.body;
+    try {
+      await _updateStatusById(orgId, status);
+      const subscription = await _getSubscriptionByOrgId(orgId);
+      if (subscription) {
+        await _updateSubscriptionStatusById(
+          subscription._id,
+          status
+        );
+      }
+      const data = await _getById(orgId);
+      res.json({
+        message: "Organization status updated successfully.",
+        data
+      });
+    } catch (err) {
+      next(err);
+    }
+  }
+  return {
+    add,
+    addOnboardingOrg,
+    getAll,
+    getOrgsByUserId,
+    getByName,
+    getById,
+    getByEmail,
+    update,
+    getOrgsByEmail,
+    getAdminOrgForResident,
+    updateStatus
+  };
+}
+
+// src/controllers/organization-v2.controller.ts
+var import_joi21 = __toESM(require("joi"));
+var import_node_server_utils38 = require("@7365admin1/node-server-utils");
+function useOrgControllerV2() {
+  const { getAll: _getAll, getOrganizationsWithSubscription: _getOrganizationsWithSubscription } = useOrgRepo();
+  async function getAll(req, res, next) {
+    const validation = import_joi21.default.object({
+      search: import_joi21.default.string().optional().allow("", null),
+      page: import_joi21.default.number().integer().min(1).allow("", null).default(1),
+      limit: import_joi21.default.number().integer().min(1).max(100).allow("", null).default(10),
+      nature: import_joi21.default.string().valid(...allowedNatures).optional().allow("", null),
+      status: import_joi21.default.string().trim().valid("active", "suspended", "deleted").optional().empty("").default("active")
+    });
+    const query = { ...req.query };
+    const { error, value } = validation.validate(query, {
+      convert: true,
+      stripUnknown: true
+    });
+    if (error) {
+      import_node_server_utils38.logger.log({ level: "error", message: error.message });
+      next(new import_node_server_utils38.BadRequestError(error.message));
+      return;
+    }
+    const search = value.search ?? "";
+    const page = typeof value.page === "number" ? value.page : parseInt(String(value.page ?? "1"), 10);
+    const limit = typeof value.limit === "number" ? value.limit : parseInt(String(value.limit ?? "10"), 10);
+    const nature = value.nature ?? "";
+    const status = value.status;
+    try {
+      const data = await _getAll({
+        search,
+        page,
+        limit,
+        nature,
+        status
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils38.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
+  async function getOrganizationsWithSubscription(req, res, next) {
+    const validation = import_joi21.default.object({
+      search: import_joi21.default.string().optional().allow("", null),
+      page: import_joi21.default.number().integer().min(1).default(1),
+      limit: import_joi21.default.number().integer().min(1).max(100).default(10),
+      status: import_joi21.default.string().trim().valid("active", "suspended", "deleted").default("active"),
+      type: import_joi21.default.string().optional().allow("", null),
+      billingCycle: import_joi21.default.string().optional().allow("", null)
+    });
+    const { error, value } = validation.validate(
+      req.query,
+      {
+        convert: true,
+        stripUnknown: true
+      }
+    );
+    if (error) {
+      next(new import_node_server_utils38.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getOrganizationsWithSubscription({
+        search: value.search ?? "",
+        page: value.page ?? 1,
+        limit: value.limit ?? 10,
+        status: value.status ?? "active",
+        type: value.type ?? "",
+        billingCycle: value.billingCycle ?? ""
+      });
+      res.json(data);
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    getAll,
+    getOrganizationsWithSubscription
+  };
+}
+
 // src/services/subscription.service.ts
 var import_node_server_utils50 = require("@7365admin1/node-server-utils");
 
@@ -25607,6 +25669,7 @@ var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
 var BuildingStatus = /* @__PURE__ */ ((BuildingStatus2) => {
   BuildingStatus2["ACTIVE"] = "active";
   BuildingStatus2["PENDING"] = "pending";
+  BuildingStatus2["DELETED"] = "deleted";
   return BuildingStatus2;
 })(BuildingStatus || {});
 var objectIdSchema = import_joi41.default.alternatives().try(
@@ -26967,12 +27030,6 @@ function useVehicleService() {
     const org = await _getById(orgId);
     if (!org)
       throw new import_node_server_utils77.BadRequestError("Org not found");
-    const allowedNatures2 = "property_management_agency" /* PROPERTY_MANAGEMENT_AGENCY */;
-    if (!allowedNatures2.includes(org.nature)) {
-      throw new import_node_server_utils77.BadRequestError(
-        "Only property management can approve vehicles."
-      );
-    }
     const vehicle = await _getVehicleById(id);
     const plate = vehicle.plates.find((p) => p._id.toString() === id);
     const _plateNumber = plate?.plateNumber;
@@ -28181,6 +28238,21 @@ function useBuildingRepo() {
   );
   async function createIndexes() {
     try {
+      const indexes = await collection.indexes();
+      const legacyUniqueIndexKeys = [
+        JSON.stringify({ name: 1 }),
+        JSON.stringify({ site: 1, name: 1 }),
+        JSON.stringify({ site: 1, block: 1 })
+      ];
+      await Promise.all(
+        indexes.map(async (index) => {
+          const key = JSON.stringify(index.key);
+          const isLegacyUniqueIndex = index.unique && legacyUniqueIndexKeys.includes(key) && index.partialFilterExpression?.status !== "active" /* ACTIVE */;
+          if (index.name && isLegacyUniqueIndex) {
+            await collection.dropIndex(index.name);
+          }
+        })
+      );
       await collection.createIndexes([
         { key: { name: "text" }, name: "text-index" },
         // { key: { name: 1 }, unique: true, name: "unique-name-index" },
@@ -28194,6 +28266,14 @@ function useBuildingRepo() {
           partialFilterExpression: {
             status: "active" /* ACTIVE */
           }
+        },
+        {
+          key: { site: 1, name: 1 },
+          unique: true,
+          name: "unique-site-name-active",
+          partialFilterExpression: {
+            status: "active" /* ACTIVE */
+          }
         }
       ]);
     } catch (error) {
@@ -28201,9 +28281,45 @@ function useBuildingRepo() {
     }
   }
   const { getBySiteBuildingLevel: _getBySiteBuildingLevel } = useBuildingUnitRepo();
+  async function assertBuildingDoesNotExist({
+    site,
+    name,
+    block,
+    excludeId,
+    session
+  }) {
+    const duplicates = [];
+    if (name) {
+      duplicates.push({ name });
+    }
+    if (block) {
+      duplicates.push({ block });
+    }
+    if (!duplicates.length) {
+      return;
+    }
+    const existing = await collection.findOne(
+      {
+        site,
+        status: "active" /* ACTIVE */,
+        ...excludeId && { _id: { $ne: excludeId } },
+        $or: duplicates
+      },
+      { session }
+    );
+    if (existing) {
+      throw new import_node_server_utils83.BadRequestError("Building already exists.");
+    }
+  }
   async function add(value, session) {
     try {
       value = MBuilding(value);
+      await assertBuildingDoesNotExist({
+        site: value.site,
+        name: value.name,
+        block: value.block,
+        session
+      });
       const res = await collection.insertOne(value, { session });
       delCachedData();
       return res.insertedId;
@@ -28242,6 +28358,21 @@ function useBuildingRepo() {
           throw new import_node_server_utils83.BadRequestError("Invalid level ID format.");
         }
       }
+      if (value.name || value.block) {
+        const currentBuilding = await collection.findOne(
+          { _id },
+          { session }
+        );
+        if (currentBuilding) {
+          await assertBuildingDoesNotExist({
+            site: currentBuilding.site,
+            name: value.name,
+            block: value.block,
+            excludeId: _id,
+            session
+          });
+        }
+      }
       if (value.name)
         await buildingUnitCollection.updateMany(
           { building: _id, status: "active" /* ACTIVE */ },
@@ -28471,7 +28602,8 @@ function useBuildingRepo() {
     try {
       const res = await collection.updateOne(
         { _id },
-        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } }
+        { $set: { status: "deleted" /* DELETED */, deletedAt: /* @__PURE__ */ new Date() } },
+        { session }
       );
       delCachedData();
       return res;
@@ -29365,18 +29497,19 @@ function useBuildingService() {
         }
       }
       const buildingUnitData = {};
-      if (building.name !== data.name) {
+      if (data.name && building.name !== data.name) {
         buildingUnitData.buildingName = data.name;
       }
-      if (building.block !== data.block) {
+      if (data.block && building.block !== data.block) {
         buildingUnitData.block = data.block;
       }
-      await updateByBuildingId(id, buildingUnitData, session);
       if (building.name === data.name) {
         delete data.name;
       }
-      console.log("data", data);
       const result = await _updateById(id, data, session);
+      if (Object.keys(buildingUnitData).length) {
+        await updateByBuildingId(id, buildingUnitData, session);
+      }
       await session.commitTransaction();
       return result;
     } catch (error) {
@@ -57193,7 +57326,7 @@ function useNewDashboardRepo() {
     const periodRange = getDateRange(period);
     const incidentCollection = db.collection(incidents_namespace_collection);
     const visitorCollection = db.collection(visitors_namespace_collection);
-    const nfcPatrolLogCollection = db.collection("nfc-patrol-logs");
+    const patrolLogCollection = db.collection("patrol.logs");
     const [
       workOrderReport,
       yesterdayWorkOrderReport,
@@ -57320,7 +57453,7 @@ function useNewDashboardRepo() {
         checkOut: null,
         status: { $ne: "deleted" }
       }),
-      nfcPatrolLogCollection.aggregate([
+      patrolLogCollection.aggregate([
         {
           $match: {
             site: { $in: [siteIdObj, siteId] },
@@ -57328,23 +57461,23 @@ function useNewDashboardRepo() {
           }
         },
         {
-          $unwind: "$checkPoints"
+          $unwind: "$cameras"
         },
         {
           $facet: {
             total: [{ $count: "count" }],
             completed: [
-              { $match: { "checkPoints.status": "Completed" } },
+              { $match: { "cameras.status": "Completed" } },
               { $count: "count" }
             ],
             skipped: [
-              { $match: { "checkPoints.status": "Skipped" } },
+              { $match: { "cameras.status": "Skipped" } },
               { $count: "count" }
             ]
           }
         }
       ]).toArray(),
-      nfcPatrolLogCollection.aggregate([
+      patrolLogCollection.aggregate([
         {
           $match: {
             site: { $in: [siteIdObj, siteId] },
@@ -57352,23 +57485,23 @@ function useNewDashboardRepo() {
           }
         },
         {
-          $unwind: "$checkPoints"
+          $unwind: "$cameras"
         },
         {
           $facet: {
             total: [{ $count: "count" }],
             completed: [
-              { $match: { "checkPoints.status": "Completed" } },
+              { $match: { "cameras.status": "Completed" } },
               { $count: "count" }
             ],
             skipped: [
-              { $match: { "checkPoints.status": "Skipped" } },
+              { $match: { "cameras.status": "Skipped" } },
               { $count: "count" }
             ]
           }
         }
       ]).toArray(),
-      nfcPatrolLogCollection.aggregate([
+      patrolLogCollection.aggregate([
         {
           $match: {
             site: { $in: [siteIdObj, siteId] },
@@ -57376,17 +57509,17 @@ function useNewDashboardRepo() {
           }
         },
         {
-          $unwind: "$checkPoints"
+          $unwind: "$cameras"
         },
         {
           $facet: {
             total: [{ $count: "count" }],
             completed: [
-              { $match: { "checkPoints.status": "Completed" } },
+              { $match: { "cameras.status": "Completed" } },
               { $count: "count" }
             ],
             skipped: [
-              { $match: { "checkPoints.status": "Skipped" } },
+              { $match: { "cameras.status": "Skipped" } },
               { $count: "count" }
             ]
           }
@@ -57417,78 +57550,127 @@ function useNewDashboardRepo() {
     const tTotal = tPatrolFacet.total[0]?.count ?? 0;
     const tCompleted = tPatrolFacet.completed[0]?.count ?? 0;
     const todayCompliance = tTotal > 0 ? tCompleted / tTotal * 100 : 0;
-    const todayString = import_moment.default.tz("Asia/Singapore").format("YYYY-MM-DD");
-    const dayIndex = import_moment.default.tz("Asia/Singapore").day();
-    const routes = await db.collection("nfc-patrol-routes").find({
-      site: { $in: [siteIdObj, siteId] },
-      days: { $in: [dayIndex] },
-      status: { $ne: "Inactive" }
-    }).toArray();
-    const expandedRoutes = [];
-    for (const route of routes) {
-      if (route.startTimes && Array.isArray(route.startTimes)) {
-        for (const startTime of route.startTimes) {
+    let activePatrolItems = [];
+    if (period === "today" /* TODAY */) {
+      const todayString = import_moment.default.tz("Asia/Singapore").format("YYYY-MM-DD");
+      const dayIndex = import_moment.default.tz("Asia/Singapore").day();
+      const repeatDay = dayIndex === 0 ? 7 : dayIndex;
+      const routes = await db.collection("patrol.route").find({
+        site: { $in: [siteIdObj, siteId] },
+        repeat: { $in: [repeatDay, String(repeatDay)] },
+        status: { $ne: "deleted" }
+      }).toArray();
+      const expandedRoutes = [];
+      for (const route of routes) {
+        if (route.start) {
           expandedRoutes.push({
             route,
-            startTime,
+            startTime: route.start,
             itemIndex: 0
           });
         }
       }
-    }
-    expandedRoutes.sort((a, b) => a.startTime.localeCompare(b.startTime));
-    const limitedRoutes = expandedRoutes.slice(0, 4);
-    limitedRoutes.forEach((item, idx) => {
-      item.itemIndex = idx + 1;
-    });
-    const activePatrolItems = await Promise.all(
-      limitedRoutes.map(async ({ route, startTime, itemIndex }) => {
-        const log = await db.collection("nfc-patrol-logs").findOne({
-          site: { $in: [siteIdObj, siteId] },
-          date: todayString,
-          "route._id": { $in: [route._id, route._id.toString()] },
-          "route.startTime": startTime
-        });
-        let person = "Unassigned";
-        if (log && log.createdBy) {
-          const userDoc = await db.collection("users").findOne({
-            _id: (0, import_node_server_utils199.toObjectId)(log.createdBy)
+      expandedRoutes.sort((a, b) => a.startTime.localeCompare(b.startTime));
+      const limitedRoutes = expandedRoutes.slice(0, 4);
+      limitedRoutes.forEach((item, idx) => {
+        item.itemIndex = idx + 1;
+      });
+      activePatrolItems = await Promise.all(
+        limitedRoutes.map(async ({ route, startTime, itemIndex }) => {
+          const log = await db.collection("patrol.logs").findOne({
+            site: { $in: [siteIdObj, siteId] },
+            route: { $in: [route._id, route._id.toString()] },
+            createdAt: { $gte: today, $lte: todayEnd }
           });
-          if (userDoc && userDoc.name) {
-            person = userDoc.name;
+          let person = "Unassigned";
+          if (log && log.assignee && log.assignee.length > 0) {
+            const userIds = log.assignee.map((id) => (0, import_node_server_utils199.toObjectId)(id));
+            const userDocs = await db.collection("members").find({ _id: { $in: userIds } }).toArray();
+            if (userDocs && userDocs.length > 0) {
+              person = userDocs.map((u) => u.name || u.email || "").filter(Boolean).join(", ");
+            }
+          } else if (log && log.createdBy) {
+            const userDoc = await db.collection("members").findOne({
+              _id: (0, import_node_server_utils199.toObjectId)(log.createdBy)
+            });
+            if (userDoc && userDoc.name) {
+              person = userDoc.name;
+            }
           }
-        }
-        let status = "pending";
-        if (log) {
-          status = "completed";
-        } else {
-          const routeTime = import_moment.default.tz(
-            `${todayString} ${startTime}`,
-            "YYYY-MM-DD HH:mm",
-            "Asia/Singapore"
-          );
-          const nowSg = import_moment.default.tz("Asia/Singapore");
-          const diffMinutes = nowSg.diff(routeTime, "minutes");
-          if (diffMinutes >= 0) {
-            if (diffMinutes <= 120) {
-              status = "on paused";
+          let status = "pending";
+          if (log) {
+            if (log.status) {
+              status = Array.isArray(log.status) ? log.status.join(", ") : log.status;
             } else {
-              status = "incomplete";
+              status = "completed";
             }
           } else {
-            status = "pending";
+            const routeTime = import_moment.default.tz(
+              `${todayString} ${startTime}`,
+              "YYYY-MM-DD HH:mm",
+              "Asia/Singapore"
+            );
+            const nowSg = import_moment.default.tz("Asia/Singapore");
+            const diffMinutes = nowSg.diff(routeTime, "minutes");
+            if (diffMinutes >= 0) {
+              if (diffMinutes <= 120) {
+                status = "on paused";
+              } else {
+                status = "incomplete";
+              }
+            } else {
+              status = "pending";
+            }
           }
-        }
-        return {
-          id: `${route._id.toString()}_${startTime}`,
-          title: route.name,
-          subtitle: `ID${String(itemIndex).padStart(3, "0")}`,
-          person,
-          status,
-          time: startTime
-        };
-      })
-    );
+          return {
+            id: `${route._id.toString()}_${startTime}`,
+            title: route.name,
+            subtitle: `ID${String(itemIndex).padStart(3, "0")}`,
+            person,
+            status,
+            time: startTime
+          };
+        })
+      );
+    } else {
+      const logs = await db.collection("patrol.logs").find({
+        site: { $in: [siteIdObj, siteId] },
+        createdAt: periodRange
+      }).sort({ createdAt: -1 }).limit(4).toArray();
+      activePatrolItems = await Promise.all(
+        logs.map(async (log) => {
+          let person = "Unassigned";
+          if (log.assignee && log.assignee.length > 0) {
+            const userIds = log.assignee.map((id) => (0, import_node_server_utils199.toObjectId)(id));
+            const userDocs = await db.collection("members").find({ _id: { $in: userIds } }).toArray();
+            if (userDocs && userDocs.length > 0) {
+              person = userDocs.map((u) => u.name || u.email || "").filter(Boolean).join(", ");
+            }
+          } else if (log.createdBy) {
+            const userDoc = await db.collection("members").findOne({
+              _id: (0, import_node_server_utils199.toObjectId)(log.createdBy)
+            });
+            if (userDoc && userDoc.name) {
+              person = userDoc.name;
+            }
+          }
+          let status = "completed";
+          if (log.status) {
+            status = Array.isArray(log.status) ? log.status.join(", ") : log.status;
+          }
+          const logTime = (0, import_moment.default)(log.createdAt).tz("Asia/Singapore").format("HH:mm");
+          const logDate = (0, import_moment.default)(log.createdAt).tz("Asia/Singapore").format("DD/MM/YYYY");
+          return {
+            id: log._id.toString(),
+            title: log.name,
+            subtitle: logDate,
+            person,
+            status,
+            time: logTime
+          };
+        })
+      );
+    }
     const data = {
       openWorkOrder: {
         count: wFacet.total[0]?.count ?? 0,
@@ -65349,6 +65531,74 @@ function usePostPrelovedRepo() {
       throw error;
     }
   }
+  async function getByOwnerId(ownerId, {
+    search = "",
+    page = 1,
+    limit = 10,
+    filter,
+    site,
+    status,
+    category
+  }, session) {
+    page = page > 0 ? page - 1 : 0;
+    let ownerObjectId;
+    try {
+      ownerObjectId = new import_mongodb137.ObjectId(ownerId);
+    } catch {
+      throw new import_node_server_utils235.BadRequestError("Invalid user ID format.");
+    }
+    if (site) {
+      try {
+        site = new import_mongodb137.ObjectId(site);
+      } catch {
+        throw new import_node_server_utils235.BadRequestError("Invalid site ID format.");
+      }
+    }
+    let categoryIds = null;
+    if (Array.isArray(category) && category.length > 0) {
+      categoryIds = category.map((cat) => {
+        try {
+          return new import_mongodb137.ObjectId(cat);
+        } catch {
+          throw new import_node_server_utils235.BadRequestError("Invalid category ID format.");
+        }
+      });
+    }
+    const query = {
+      status: { $ne: "deleted" /* DELETED */ },
+      createdBy: ownerObjectId,
+      ...site && { site },
+      ...search && {
+        $or: [
+          { title: { $regex: search, $options: "i" } },
+          { description: { $regex: search, $options: "i" } }
+        ]
+      },
+      ...status && {
+        status: { $in: Array.isArray(status) ? status : [status] }
+      },
+      ...categoryIds && { category: { $in: categoryIds } }
+    };
+    const sortObj = buildSortObj(filter);
+    try {
+      const items = await collection.aggregate(
+        [
+          { $match: query },
+          USER_LOOKUP,
+          USER_UNWIND,
+          CATEGORY_LOOKUP,
+          { $sort: sortObj },
+          { $skip: page * limit },
+          { $limit: limit }
+        ],
+        { session }
+      ).toArray();
+      const length = await collection.countDocuments(query, { session });
+      return (0, import_node_server_utils235.paginate)(items, page, limit, length);
+    } catch (error) {
+      throw error;
+    }
+  }
   async function updateById(_id, value, session) {
     try {
       _id = new import_mongodb137.ObjectId(_id);
@@ -65419,6 +65669,7 @@ function usePostPrelovedRepo() {
     add,
     getById,
     getAll,
+    getByOwnerId,
     updateById,
     deleteById,
     updateStatus
@@ -65628,6 +65879,7 @@ function usePostPrelovedController() {
   const {
     getById: _getById,
     getAll: _getAll,
+    getByOwnerId: _getByOwnerId,
     updateById: _updateById,
     deleteById: _deleteById,
     updateStatus: _updateStatus
@@ -65731,6 +65983,49 @@ function usePostPrelovedController() {
       return;
     }
   }
+  async function getByOwnerId(req, res, next) {
+    const validation = import_joi135.default.object({
+      ownerId: import_joi135.default.string().hex().length(24).required(),
+      page: import_joi135.default.number().integer().min(1).allow("", null).default(1),
+      limit: import_joi135.default.number().integer().min(1).max(100).allow("", null).default(10),
+      search: import_joi135.default.string().optional().allow("", null),
+      filter: import_joi135.default.string().valid("recent", "price-low-high", "price-high-low").optional().allow("", null),
+      site: import_joi135.default.string().hex().length(24).optional().allow("", null),
+      status: import_joi135.default.alternatives().try(
+        import_joi135.default.array().items(import_joi135.default.string().valid(...Object.values(PostStatus))),
+        import_joi135.default.string().valid(...Object.values(PostStatus))
+      ).optional().allow(null),
+      category: import_joi135.default.array().items(import_joi135.default.string().hex().length(24)).single().optional().allow(null)
+    });
+    const { error, value } = validation.validate(
+      { ...req.query, ownerId: req.params.ownerId },
+      { abortEarly: false }
+    );
+    if (error) {
+      const messages = error.details.map((d) => d.message).join(", ");
+      import_node_server_utils238.logger.log({ level: "error", message: messages });
+      next(new import_node_server_utils238.BadRequestError(messages));
+      return;
+    }
+    const { ownerId, page, limit, search, filter, site, status, category } = value;
+    try {
+      const data = await _getByOwnerId(ownerId, {
+        page,
+        limit,
+        search,
+        filter,
+        site,
+        status: status ? Array.isArray(status) ? status : [status] : void 0,
+        category: category ?? void 0
+      });
+      res.status(200).json(data);
+      return;
+    } catch (error2) {
+      import_node_server_utils238.logger.log({ level: "error", message: error2.message });
+      next(error2);
+      return;
+    }
+  }
   async function updateById(req, res, next) {
     const _id = req.params.id;
     const payload = { _id, ...req.body };
@@ -65801,6 +66096,7 @@ function usePostPrelovedController() {
     add,
     getById,
     getAll,
+    getByOwnerId,
     updateById,
     deleteById,
     updateStatus