@7365admin1/core 2.56.0 → 2.57.0

package/dist/index.mjs

@@ -4892,34 +4892,55 @@ function useSiteRepo() {
     const query = {
       status: { $ne: "deleted" }
     };
-    const cacheOptions = {
-      status: { $ne: "deleted" },
-      page,
-      limit
-    };
     if (search) {
       query.$or = [{ name: { $regex: search, $options: "i" } }];
-      cacheOptions.search = search;
-    }
-    const cacheKey = makeCacheKey9(namespace_collection, cacheOptions);
-    const cachedData = await getCache(cacheKey);
-    if (cachedData) {
-      logger12.info(`Cache hit for key: ${cacheKey}`);
-      return cachedData;
     }
+    const basePipeline = [
+      { $match: query },
+      {
+        $lookup: {
+          from: "buildings",
+          let: { siteId: "$_id" },
+          pipeline: [
+            {
+              $match: {
+                $expr: { $eq: ["$site", "$$siteId"] },
+                status: { $ne: "deleted" }
+              }
+            }
+          ],
+          as: "buildings"
+        }
+      },
+      { $match: { "buildings.0": { $exists: true } } },
+      {
+        $lookup: {
+          from: "building-units",
+          let: { buildingIds: "$buildings._id" },
+          pipeline: [
+            {
+              $match: {
+                $expr: { $in: ["$building", "$$buildingIds"] },
+                status: { $ne: "deleted" }
+              }
+            },
+            { $limit: 1 }
+          ],
+          as: "units"
+        }
+      },
+      { $match: { "units.0": { $exists: true } } }
+    ];
     try {
       const items = await collection.aggregate([
-        { $match: query },
+        ...basePipeline,
+        { $project: { _id: 1, name: 1 } },
         { $skip: page * limit },
         { $limit: limit }
       ]).toArray();
-      const length = await collection.countDocuments(query);
+      const countResult = await collection.aggregate([...basePipeline, { $count: "total" }]).toArray();
+      const length = countResult[0]?.total ?? 0;
       const data = paginate8(items, page, limit, length);
-      setCache(cacheKey, data, 15 * 60).then(() => {
-        logger12.info(`Cache set for key: ${cacheKey}`);
-      }).catch((err) => {
-        logger12.error(`Failed to set cache for key: ${cacheKey}`, err);
-      });
       return data;
     } catch (error) {
       throw error;
@@ -19359,6 +19380,66 @@ function useBuildingRepo() {
       throw error;
     }
   }
+  async function getAllBuildingForResident({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    site = "",
+    status = "active" /* ACTIVE */
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    let siteId;
+    if (site) {
+      try {
+        siteId = new ObjectId49(site);
+      } catch (error) {
+        throw new BadRequestError79("Invalid site ID.");
+      }
+    }
+    const query = {
+      status,
+      ...search && { $text: { $search: search } },
+      ...siteId && { site: siteId }
+    };
+    sort = Object.keys(sort).length ? sort : { _id: -1 };
+    const basePipeline = [
+      { $match: query },
+      { $match: { $expr: { $gt: [{ $size: "$levels" }, 0] } } },
+      {
+        $lookup: {
+          from: "building-units",
+          let: { buildingId: "$_id" },
+          pipeline: [
+            {
+              $match: {
+                $expr: { $eq: ["$building", "$$buildingId"] },
+                status: { $ne: "deleted" }
+              }
+            },
+            { $limit: 1 }
+          ],
+          as: "units"
+        }
+      },
+      { $match: { "units.0": { $exists: true } } }
+    ];
+    try {
+      const items = await collection.aggregate([
+        ...basePipeline,
+        { $project: { units: 0 } },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const countResult = await collection.aggregate([...basePipeline, { $count: "total" }]).toArray();
+      const length = countResult[0]?.total ?? 0;
+      return paginate22(items, page, limit, length);
+    } catch (error) {
+      logger60.log({ level: "error", message: `${error}` });
+      throw error;
+    }
+  }
   async function getById(_id) {
     try {
       _id = new ObjectId49(_id);
@@ -19480,7 +19561,6 @@ function useBuildingRepo() {
     const cacheOptions = { ...query };
     const cacheKey = makeCacheKey26(buildings_namespace_collection, cacheOptions);
     try {
-      console.log(query);
       const result = await collection.aggregate([
         {
           $match: {
@@ -19530,16 +19610,16 @@ function useBuildingRepo() {
         },
         {
           $project: {
-            "_id": 1,
-            "site": 1,
-            "name": 1,
-            "block": 1,
-            "status": 1,
-            "buildingFloorPlan": 1,
-            "createdAt": 1,
-            "updatedAt": 1,
-            "deletedAt": 1,
-            "levels": "$buildingLevels"
+            _id: 1,
+            site: 1,
+            name: 1,
+            block: 1,
+            status: 1,
+            buildingFloorPlan: 1,
+            createdAt: 1,
+            updatedAt: 1,
+            deletedAt: 1,
+            levels: "$buildingLevels"
           }
         }
       ]).toArray();
@@ -19572,6 +19652,7 @@ function useBuildingRepo() {
     createIndexes,
     add,
     getAll,
+    getAllBuildingForResident,
     getById,
     updateById,
     deleteById,
@@ -19718,10 +19799,56 @@ function useBuildingService() {
       throw error;
     }
   }
+  async function uploadSpreadsheetBuilding(data, site) {
+    const session = useAtlas39.getClient()?.startSession();
+    if (!session) {
+      throw new BadRequestError80("Database session not available.");
+    }
+    try {
+      session?.startTransaction();
+      const blockMap = /* @__PURE__ */ new Map();
+      for (const row of data) {
+        const block = row.block;
+        const name = row.name;
+        const rawLevel = row.level?.toString().trim();
+        const normalizedLevel = /^(na|n\/a)$/i.test(rawLevel) ? null : `Lvl${rawLevel}`;
+        if (!blockMap.has(block)) {
+          blockMap.set(block, { name, levels: [] });
+        }
+        const blockEntry = blockMap.get(block);
+        if (blockEntry.name !== name) {
+          blockEntry.name = `${blockEntry.name}, ${name}`;
+        }
+        if (normalizedLevel && !blockEntry.levels.includes(normalizedLevel)) {
+          blockEntry.levels.push(normalizedLevel);
+        }
+      }
+      const buildingPayloads = Array.from(blockMap.entries()).map(
+        ([block, { name, levels }]) => ({
+          site,
+          block,
+          name,
+          levels
+        })
+      );
+      for (const buildingPayload of buildingPayloads) {
+        const result = await _add(buildingPayload);
+        console.log("Inserted:", result);
+      }
+      await session?.commitTransaction();
+      return buildingPayloads;
+    } catch (error) {
+      await session?.abortTransaction();
+      throw error;
+    } finally {
+      session?.endSession();
+    }
+  }
   return {
     add,
     updateById,
-    deleteById
+    deleteById,
+    uploadSpreadsheetBuilding
   };
 }
 
@@ -19734,6 +19861,7 @@ import fs from "fs";
 function useBuildingController() {
   const {
     getAll: _getAll,
+    getAllBuildingForResident: _getAllBuildingForResident,
     getById: _getById,
     getBuildingLevel: _getBuildingLevel,
     getBuildingLevelWithUnits: _getBuildingLevelWithUnits
@@ -19741,7 +19869,8 @@ function useBuildingController() {
   const {
     updateById: _updateById,
     deleteById: _deleteById,
-    add: _add
+    add: _add,
+    uploadSpreadsheetBuilding: _uploadSpreadsheetBuilding
   } = useBuildingService();
   async function createBuilding(req, res, next) {
     const value = req.body;
@@ -19834,6 +19963,40 @@ function useBuildingController() {
       next(error2);
     }
   }
+  async function getAllBuildingForResident(req, res, next) {
+    const query = req.query;
+    const validation = Joi44.object({
+      page: Joi44.number().min(1).optional().default(1),
+      limit: Joi44.number().min(1).optional().default(10),
+      search: Joi44.string().optional().allow("", null),
+      site: Joi44.string().hex().optional().allow("", null),
+      status: Joi44.string().valid(...Object.values(BuildingStatus)).default("active" /* ACTIVE */),
+      sort: Joi44.string().valid(...Object.values(SortFields)).default("_id" /* ID */),
+      order: Joi44.string().valid(...Object.values(SortOrder)).default("asc" /* ASC */)
+    });
+    const { error, value } = validation.validate(query);
+    if (error) {
+      next(new BadRequestError81(error.message));
+      return;
+    }
+    const sortObj = {
+      [value.sort]: value.order === "asc" /* ASC */ ? 1 : -1
+    };
+    try {
+      const buildings = await _getAllBuildingForResident({
+        page: value.page,
+        limit: value.limit,
+        sort: sortObj,
+        status: value.status,
+        site: value.site ?? "",
+        search: value.search ?? ""
+      });
+      res.json(buildings);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
   async function getById(req, res, next) {
     const id = req.params.id;
     const validation = Joi44.object({
@@ -19988,6 +20151,7 @@ function useBuildingController() {
           validRows.push(value);
         }
       });
+      await _uploadSpreadsheetBuilding(validRows, site);
       res.status(200).json({
         message: "Spreadsheet import completed (buildings).",
         fileName: originalname,
@@ -20028,6 +20192,7 @@ function useBuildingController() {
   return {
     createBuilding,
     getAll,
+    getAllBuildingForResident,
     getById,
     updateById,
     deleteById,