@7365admin1/core 2.10.0 → 2.11.0

package/dist/index.mjs

@@ -934,6 +934,7 @@ function useWorkOrderRepo() {
     }
   }
   const { delNamespace, setCache, getCache, delCache } = useCache3(namespace_collection);
+  const { delNamespace: _delDashboardNameSpace } = useCache3("dashboard");
   async function createWorkOrder(value, session) {
     try {
       value = MWorkOrder(value);
@@ -946,6 +947,11 @@ function useWorkOrderRepo() {
           err
         );
       });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
+      });
       return res.insertedId;
     } catch (error) {
       throw error;
@@ -1182,11 +1188,18 @@ function useWorkOrderRepo() {
       if (res.modifiedCount === 0) {
         throw new InternalServerError3("Unable to update work order.");
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1209,11 +1222,18 @@ function useWorkOrderRepo() {
       if (res.modifiedCount === 0) {
         throw new InternalServerError3("Unable to update work order status.");
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1231,11 +1251,18 @@ function useWorkOrderRepo() {
         { $set: updateValue },
         session
       );
-      const cacheKey = makeCacheKey3(namespace_collection, { createdBy: _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1265,11 +1292,18 @@ function useWorkOrderRepo() {
           "Unable to mark work order as completed."
         );
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
+      }).catch((err) => {
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -1296,11 +1330,18 @@ function useWorkOrderRepo() {
       if (res.modifiedCount === 0) {
         throw new InternalServerError3("Unable to delete work order.");
       }
-      const cacheKey = makeCacheKey3(namespace_collection, { _id });
-      delCache(cacheKey).then(() => {
-        logger5.info(`Cache deleted for key: ${cacheKey}`);
+      delNamespace().then(() => {
+        logger5.info(`Cache cleared for namespace: ${namespace_collection}`);
       }).catch((err) => {
-        logger5.error(`Failed to delete cache for key: ${cacheKey}`, err);
+        logger5.error(
+          `Failed to clear cache for namespace: ${namespace_collection}`,
+          err
+        );
+      });
+      _delDashboardNameSpace().then(() => {
+        logger5.info(`Cache cleared for namespace: dashboard`);
+      }).catch((err) => {
+        logger5.error(`Failed to clear cache for namespace: dashboard`, err);
       });
       return res.modifiedCount;
     } catch (error) {
@@ -2858,6 +2899,14 @@ function useVerificationRepo() {
       throw new InternalServerError7("Error updating verification status.");
     }
   }
+  async function getByStatus(status) {
+    try {
+      const data = await collection.find({ status }).toArray();
+      return data;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
   return {
     createIndex,
     createTextIndex,
@@ -2865,7 +2914,8 @@ function useVerificationRepo() {
     getById,
     getVerifications,
     getByIdByType,
-    updateStatusById
+    updateStatusById,
+    getByStatus
   };
 }
 
@@ -4119,7 +4169,8 @@ function useVerificationService() {
   const {
     add,
     getById: _getById,
-    updateStatusById: _updateStatusById
+    updateStatusById: _updateStatusById,
+    getByStatus: _getByStatus
   } = useVerificationRepo();
   const { getUserByEmail } = useUserRepo();
   const { getById: getOrgById, getByEmail: getOrgByEmail } = useOrgRepo();
@@ -4365,7 +4416,6 @@ function useVerificationService() {
   }
   async function cancelUserInvitation(id) {
     try {
-      await verify(id);
       await updateStatusById(id, "cancelled");
     } catch (error) {
       throw new InternalServerError11(
@@ -4427,6 +4477,30 @@ function useVerificationService() {
       throw error;
     }
   }
+  async function checkExpiredInvitation() {
+    const session = useAtlas10.getClient()?.startSession();
+    session?.startTransaction();
+    try {
+      const verifications = await _getByStatus("pending");
+      for (const verification of verifications) {
+        const expiration = new Date(verification.expireAt).getTime();
+        const now = (/* @__PURE__ */ new Date()).getTime();
+        if (now > expiration) {
+          await _updateStatusById(verification._id.toString(), "expired");
+        }
+      }
+      return "Successfully checked for expired invitations.";
+    } catch (error) {
+      await session?.abortTransaction();
+      logger14.log({
+        level: "info",
+        message: `Error checking expired user invitation: ${error}`
+      });
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
   return {
     createUserInvite,
     createForgetPassword,
@@ -4435,7 +4509,8 @@ function useVerificationService() {
     verify,
     cancelUserInvitation,
     updateStatusById,
-    signUp
+    signUp,
+    checkExpiredInvitation
   };
 }
 
@@ -5645,6 +5720,16 @@ function useFileRepo() {
   const namespace_collection = "files";
   const collection = db.collection(namespace_collection);
   const { delNamespace, getCache, setCache } = useCache13(namespace_collection);
+  async function createIndex() {
+    try {
+      await collection.createIndexes([
+        { key: { createdAt: 1 } },
+        { key: { status: 1 } }
+      ]);
+    } catch (error) {
+      throw new InternalServerError14("Failed to create index on feedback.");
+    }
+  }
   async function createFile(value, session) {
     try {
       value = new MFile(value);
@@ -5773,7 +5858,8 @@ function useFileRepo() {
     deleteFileById,
     getAllDraftedFiles,
     updateStatusById,
-    getFileById
+    getFileById,
+    createIndex
   };
 }
 
@@ -27647,22 +27733,31 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  function getAfterSecondSlash(term) {
+    const first = term.indexOf("/");
+    if (first === -1)
+      return "";
+    const second = term.indexOf("/", first + 1);
+    if (second === -1)
+      return "";
+    return term.substring(second + 1).toLowerCase();
+  }
   function buildSearchQuery(search) {
     if (!search) {
       return {};
     }
     const terms = search.split("/").map((s) => s.trim()).filter(Boolean);
-    if (search.includes("/") && terms.length <= 3) {
-      switch (terms.length) {
-        case 3:
+    if (search.includes("/")) {
+      switch (true) {
+        case terms.length >= 3:
           return {
             $and: [
               { $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] } },
               { $expr: { $eq: [{ $toLower: "$level.level" }, terms[1].toLowerCase()] } },
-              { $expr: { $eq: [{ $toLower: "$level.units.name" }, terms[2].toLowerCase()] } }
+              { $expr: { $eq: [{ $toLower: "$level.units.name" }, getAfterSecondSlash(search)] } }
             ]
           };
-        case 2:
+        case terms.length === 2:
           return {
             $and: [
               { $expr: { $eq: [{ $toLower: "$name" }, terms[0].toLowerCase()] } },
@@ -27893,6 +27988,172 @@ function UseAccessManagementRepo() {
       throw new Error(error.message);
     }
   }
+  async function assignedAccessCardsRepo(params) {
+    try {
+      const site = new ObjectId83(params.site);
+      const userType = params.userType;
+      const type = params.type;
+      const search = params.search;
+      const query = {
+        site: { $in: [site] }
+      };
+      const searchQuery = buildSearchQuery(search);
+      const result = await collectionName("buildings").aggregate([
+        // ✅ Match early with index-friendly query
+        {
+          $match: {
+            ...query,
+            status: { $ne: "deleted" }
+          }
+        },
+        // ✅ Only project needed fields before heavy lookups
+        {
+          $project: {
+            _id: 1,
+            name: 1,
+            site: 1
+          }
+        },
+        // ✅ Use localField/foreignField for better index usage
+        {
+          $lookup: {
+            from: "building-levels",
+            localField: "_id",
+            foreignField: "block",
+            pipeline: [
+              { $match: { status: { $ne: "deleted" } } },
+              {
+                $lookup: {
+                  from: "building-units",
+                  localField: "_id",
+                  foreignField: "level",
+                  pipeline: [
+                    { $match: { status: { $ne: "deleted" } } },
+                    { $project: { _id: 1, name: 1 } },
+                    {
+                      $lookup: {
+                        from: "access-cards",
+                        localField: "_id",
+                        foreignField: "assignedUnit",
+                        pipeline: [
+                          {
+                            $match: {
+                              isActivated: true,
+                              userType,
+                              type
+                            }
+                          },
+                          {
+                            $group: {
+                              _id: null,
+                              accessLevels: { $addToSet: "$accessLevel" },
+                              liftAccessLevels: { $addToSet: "$liftAccessLevel" },
+                              doorNames: { $addToSet: "$doorName" },
+                              liftNames: { $addToSet: "$liftName" },
+                              cards: {
+                                $push: {
+                                  _id: "$_id",
+                                  cardNo: "$cardNo",
+                                  accessLevel: "$accessLevel",
+                                  liftAccessLevel: "$liftAccessLevel",
+                                  doorName: "$doorName",
+                                  liftName: "$liftName"
+                                }
+                              }
+                            }
+                          },
+                          {
+                            $project: {
+                              _id: 0,
+                              accessCardCount: {
+                                $size: "$cards"
+                              },
+                              accessLevels: 1,
+                              liftAccessLevels: 1,
+                              doorNames: 1,
+                              liftNames: 1
+                            }
+                          }
+                        ],
+                        as: "fAccessCards"
+                      }
+                    },
+                    {
+                      $match: {
+                        "fAccessCards.0": { $exists: true }
+                      }
+                    }
+                  ],
+                  as: "units"
+                }
+              },
+              {
+                $match: { "units.0": { $exists: true } }
+              },
+              {
+                $project: {
+                  _id: 1,
+                  level: 1,
+                  units: 1
+                }
+              }
+            ],
+            as: "level"
+          }
+        },
+        // ✅ Filter out buildings with no levels early
+        {
+          $match: { "level.0": { $exists: true } }
+        },
+        // ✅ Unwind to flatten the hierarchy
+        {
+          $unwind: {
+            path: "$level",
+            preserveNullAndEmptyArrays: false
+          }
+        },
+        {
+          $unwind: {
+            path: "$level.units",
+            preserveNullAndEmptyArrays: false
+          }
+        },
+        {
+          $unwind: {
+            path: "$level.units.fAccessCards",
+            preserveNullAndEmptyArrays: false
+          }
+        },
+        // // Groups by unit _id and keeps only the first occurrence
+        {
+          $group: {
+            _id: "$level.units._id",
+            doc: { $first: "$$ROOT" }
+          }
+        },
+        {
+          $replaceRoot: { newRoot: "$doc" }
+        },
+        // ✅ Apply search filter
+        {
+          $match: {
+            ...searchQuery
+          }
+        },
+        {
+          $project: {
+            name: 1,
+            "level.level": 1,
+            "level.units.name": 1,
+            "level.units.fAccessCards": 1
+          }
+        }
+      ], { allowDiskUse: true }).toArray();
+      return result;
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
   return {
     createIndexes,
     createIndexForEntrypass,
@@ -27901,7 +28162,8 @@ function UseAccessManagementRepo() {
     accessManagementSettingsRepo,
     allAccessCardsCountsRepo,
     availableAccessCardsRepo,
-    userTypeAccessCardsRepo
+    userTypeAccessCardsRepo,
+    assignedAccessCardsRepo
   };
 }
 
@@ -28006,6 +28268,8 @@ var formatAccessGroup = (data, search) => {
 
 // src/services/access-management.service.ts
 import { parseStringPromise } from "xml2js";
+import { useCache as useCache47 } from "@7365admin1/node-server-utils";
+var namespace = "cache:acm";
 function useAccessManagementSvc() {
   const {
     addPhysicalCardRepo,
@@ -28013,7 +28277,8 @@ function useAccessManagementSvc() {
     accessManagementSettingsRepo,
     allAccessCardsCountsRepo,
     availableAccessCardsRepo,
-    userTypeAccessCardsRepo
+    userTypeAccessCardsRepo,
+    assignedAccessCardsRepo
   } = UseAccessManagementRepo();
   const addPhysicalCardSvc = async (payload) => {
     try {
@@ -28031,12 +28296,34 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
+  const setCache = async (params) => {
+    const { key, data, ttlSeconds = 60, redis } = params;
+    const jsonData = JSON.stringify(data);
+    await redis.set(key, jsonData, "EX", ttlSeconds);
+  };
+  const getCache = async (params) => {
+    const { key, redis } = params;
+    const result = await redis.get(key);
+    return result ? JSON.parse(result) : null;
+  };
   const doorAccessLevelsSvc = async (params) => {
     try {
+      const key = `${namespace}:${params.user}:door-levels`;
+      const listKey = `${namespace}:${params.user}:list`;
+      const { redis } = useCache47(key);
+      const cachedData = await getCache({ key, redis });
+      if (cachedData) {
+        console.log("\u26A1 Cache hit:", key);
+        redis.expire(key, 60).catch(console.error);
+        redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
+        return cachedData;
+      }
       const command = readTemplate("door-levels");
       const response = await sendCommand(command, params.acm_url);
       const res = await parseStringPromise(response, { explicitArray: false });
       const format = await formatDoorAccessLevels(res);
+      await setCache({ key, data: format, ttlSeconds: 60, redis });
+      redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
       return format;
     } catch (err) {
       throw new Error(err.message);
@@ -28044,10 +28331,22 @@ function useAccessManagementSvc() {
   };
   const liftAccessLevelsSvc = async (params) => {
     try {
+      const key = `${namespace}:${params.user}:lift-levels`;
+      const listKey = `${namespace}:${params.user}:list`;
+      const { redis } = useCache47(key);
+      const cachedData = await getCache({ key, redis });
+      if (cachedData) {
+        console.log("\u26A1 Cache hit:", key);
+        redis.expire(key, 60).catch(console.error);
+        redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
+        return cachedData;
+      }
       const command = readTemplate("lift-levels");
       const response = await sendCommand(command, params.acm_url);
       const res = await parseStringPromise(response, { explicitArray: false });
       const format = await formatLiftAccessLevels(res);
+      await setCache({ key, data: format, ttlSeconds: 60, redis });
+      redis.lrem(listKey, 0, key).then(() => redis.lpush(listKey, key)).then(() => redis.ltrim(listKey, 0, 9)).catch(console.error);
       return format;
     } catch (error) {
       throw new Error(error.message);
@@ -28096,6 +28395,14 @@ function useAccessManagementSvc() {
       throw new Error(err.message);
     }
   };
+  const assignedAccessCardsSvc = async (params) => {
+    try {
+      const response = await assignedAccessCardsRepo({ ...params });
+      return response;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  };
   return {
     addPhysicalCardSvc,
     addNonPhysicalCardSvc,
@@ -28105,7 +28412,8 @@ function useAccessManagementSvc() {
     accessManagementSettingsSvc,
     allAccessCardsCountsSvc,
     availableAccessCardsSvc,
-    userTypeAccessCardsSvc
+    userTypeAccessCardsSvc,
+    assignedAccessCardsSvc
   };
 }
 
@@ -28120,7 +28428,8 @@ function useAccessManagementController() {
     accessManagementSettingsSvc,
     allAccessCardsCountsSvc,
     availableAccessCardsSvc,
-    userTypeAccessCardsSvc
+    userTypeAccessCardsSvc,
+    assignedAccessCardsSvc
   } = useAccessManagementSvc();
   const addPhysicalCard = async (req, res) => {
     try {
@@ -28251,10 +28560,11 @@ function useAccessManagementController() {
   const doorAccessLevels = async (req, res) => {
     try {
       const { acm_url } = req.query;
+      const user = req.cookies?.sid;
       if (!acm_url || typeof acm_url !== "string") {
         throw new Error("Access Control URL is required");
       }
-      const result = await doorAccessLevelsSvc({ acm_url });
+      const result = await doorAccessLevelsSvc({ acm_url, user });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(400).json({
@@ -28266,10 +28576,11 @@ function useAccessManagementController() {
   const liftAccessLevels = async (req, res) => {
     try {
       const { acm_url } = req.query;
+      const user = req.cookies?.sid;
       if (!acm_url || typeof acm_url !== "string") {
         throw new Error("Access Control URL is required");
       }
-      const result = await liftAccessLevelsSvc({ acm_url });
+      const result = await liftAccessLevelsSvc({ acm_url, user });
       return res.status(200).json({ message: "Success", data: result });
     } catch (error) {
       return res.status(400).json({
@@ -28377,6 +28688,28 @@ function useAccessManagementController() {
       });
     }
   };
+  const assignedAccessCards = async (req, res) => {
+    try {
+      const { site, userType, type, search = "" } = req.query;
+      const schema2 = Joi85.object({
+        site: Joi85.string().hex().required(),
+        userType: Joi85.string().required(),
+        type: Joi85.string().required(),
+        search: Joi85.string().optional().allow("", null)
+      });
+      const { error } = schema2.validate({ site, userType, type, search });
+      if (error) {
+        return res.status(400).json({ message: error.message });
+      }
+      const result = await assignedAccessCardsSvc({ site, userType, type, search });
+      return res.status(200).json({ message: "Success", data: result });
+    } catch (error) {
+      return res.status(500).json({
+        data: null,
+        message: error.message
+      });
+    }
+  };
   return {
     addPhysicalCard,
     addNonPhysicalCard,
@@ -28386,7 +28719,8 @@ function useAccessManagementController() {
     accessManagementSettings,
     allAccessCardsCounts,
     availableAccessCards,
-    userTypeAccessCards
+    userTypeAccessCards,
+    assignedAccessCards
   };
 }
 
@@ -28456,7 +28790,7 @@ import {
   makeCacheKey as makeCacheKey45,
   paginate as paginate39,
   useAtlas as useAtlas75,
-  useCache as useCache47
+  useCache as useCache48
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId85 } from "mongodb";
 function useNfcPatrolTagRepo() {
@@ -28467,8 +28801,8 @@ function useNfcPatrolTagRepo() {
   const namespace_collection = "nfc-patrol-tags";
   const namespace_collection_nfc_patrol_routes = "nfc-patrol-routes";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache47(namespace_collection);
-  const { delNamespace: delNamespaceNfcPatrolRoutes } = useCache47(
+  const { delNamespace, getCache, setCache } = useCache48(namespace_collection);
+  const { delNamespace: delNamespaceNfcPatrolRoutes } = useCache48(
     namespace_collection_nfc_patrol_routes
   );
   async function createIndexes() {
@@ -28915,7 +29249,7 @@ import {
   NotFoundError as NotFoundError37,
   paginate as paginate40,
   useAtlas as useAtlas77,
-  useCache as useCache48
+  useCache as useCache49
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId87 } from "mongodb";
 function useOccurrenceBookRepo() {
@@ -28947,7 +29281,7 @@ function useOccurrenceBookRepo() {
   }
   const namespace_collection = "occurrence-books";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache48(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache49(namespace_collection);
   async function add(value, session) {
     try {
       value = MOccurrenceBook(value);
@@ -29525,7 +29859,7 @@ import {
   NotFoundError as NotFoundError38,
   paginate as paginate41,
   useAtlas as useAtlas79,
-  useCache as useCache49
+  useCache as useCache50
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId89 } from "mongodb";
 function useBulletinVideoRepo() {
@@ -29544,7 +29878,7 @@ function useBulletinVideoRepo() {
   }
   const namespace_collection = "bulletin-videos";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache49(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache50(namespace_collection);
   async function add(value, session) {
     try {
       value = MBulletinVideo(value);
@@ -30076,7 +30410,7 @@ import {
   InternalServerError as InternalServerError51,
   logger as logger127,
   useAtlas as useAtlas81,
-  useCache as useCache50,
+  useCache as useCache51,
   paginate as paginate42,
   makeCacheKey as makeCacheKey48
 } from "@7365admin1/node-server-utils";
@@ -30088,7 +30422,7 @@ function useStatementOfAccountRepo() {
   }
   const namespace_collection = "site.statement-of-accounts";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache50(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache51(namespace_collection);
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -30851,7 +31185,7 @@ import {
   NotFoundError as NotFoundError40,
   paginate as paginate43,
   useAtlas as useAtlas83,
-  useCache as useCache51
+  useCache as useCache52
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId93 } from "mongodb";
 function useEntryPassSettingsRepo() {
@@ -30861,7 +31195,7 @@ function useEntryPassSettingsRepo() {
   }
   const namespace_collection = "site.entrypass-settings";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache51(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache52(namespace_collection);
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -31423,7 +31757,7 @@ import {
   logger as logger133,
   makeCacheKey as makeCacheKey50,
   useAtlas as useAtlas84,
-  useCache as useCache52
+  useCache as useCache53
 } from "@7365admin1/node-server-utils";
 function useDashboardRepo() {
   const db = useAtlas84.getDb();
@@ -31434,7 +31768,7 @@ function useDashboardRepo() {
   const work_order_collection = db.collection("work-orders");
   const visitor_collection = db.collection("visitor.transactions");
   const namespace_collection = "dashboard";
-  const { delNamespace, getCache, setCache } = useCache52(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache53(namespace_collection);
   async function getAll({
     site = ""
   }, session) {
@@ -31598,7 +31932,7 @@ import {
   makeCacheKey as makeCacheKey51,
   paginate as paginate44,
   useAtlas as useAtlas85,
-  useCache as useCache53
+  useCache as useCache54
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId95 } from "mongodb";
 function useNfcPatrolRouteRepo() {
@@ -31608,7 +31942,7 @@ function useNfcPatrolRouteRepo() {
   }
   const namespace_collection = "nfc-patrol-routes";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache53(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache54(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([
@@ -32345,7 +32679,7 @@ import {
   NotFoundError as NotFoundError43,
   paginate as paginate45,
   useAtlas as useAtlas87,
-  useCache as useCache54
+  useCache as useCache55
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId97 } from "mongodb";
 function useIncidentReportRepo() {
@@ -32376,7 +32710,7 @@ function useIncidentReportRepo() {
   }
   const namespace_collection = "incident-reports";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache54(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache55(namespace_collection);
   async function add(value, session) {
     try {
       value = MIncidentReport(value);
@@ -33117,7 +33451,7 @@ import {
   makeCacheKey as makeCacheKey53,
   NotFoundError as NotFoundError45,
   useAtlas as useAtlas89,
-  useCache as useCache55
+  useCache as useCache56
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId99 } from "mongodb";
 function useNfcPatrolSettingsRepository() {
@@ -33127,7 +33461,7 @@ function useNfcPatrolSettingsRepository() {
   }
   const namespace_collection = "site.nfc-patrol-settings";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, setCache, getCache } = useCache55(namespace_collection);
+  const { delNamespace, setCache, getCache } = useCache56(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([{ key: { site: 1 }, unique: true }]);
@@ -33372,7 +33706,7 @@ import {
   NotFoundError as NotFoundError46,
   paginate as paginate46,
   useAtlas as useAtlas91,
-  useCache as useCache56
+  useCache as useCache57
 } from "@7365admin1/node-server-utils";
 
 // src/models/occurrence-subject.model.ts
@@ -33449,7 +33783,7 @@ function useOccurrenceSubjectRepo() {
   }
   const namespace_collection = "occurrence-subjects";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache56(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache57(namespace_collection);
   async function add(value, session) {
     try {
       value = MOccurrenceSubject(value);
@@ -34017,7 +34351,7 @@ import {
   NotFoundError as NotFoundError47,
   paginate as paginate47,
   useAtlas as useAtlas93,
-  useCache as useCache57
+  useCache as useCache58
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId103 } from "mongodb";
 function useOnlineFormRepo() {
@@ -34027,7 +34361,7 @@ function useOnlineFormRepo() {
   }
   const namespace_collection = "online-forms";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache57(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache58(namespace_collection);
   async function createTextIndex() {
     try {
       await collection.createIndex({
@@ -34763,7 +35097,7 @@ import {
   makeCacheKey as makeCacheKey56,
   paginate as paginate48,
   useAtlas as useAtlas95,
-  useCache as useCache58
+  useCache as useCache59
 } from "@7365admin1/node-server-utils";
 import { ObjectId as ObjectId105 } from "mongodb";
 function useNfcPatrolLogRepo() {
@@ -34773,7 +35107,7 @@ function useNfcPatrolLogRepo() {
   }
   const namespace_collection = "nfc-patrol-logs";
   const collection = db.collection(namespace_collection);
-  const { delNamespace, getCache, setCache } = useCache58(namespace_collection);
+  const { delNamespace, getCache, setCache } = useCache59(namespace_collection);
   async function createIndexes() {
     try {
       await collection.createIndexes([