@7365admin1/core 3.21.0 → 3.22.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @iservice365/core
 
+## 3.22.0
+
+### Minor Changes
+
+- 8590d35: release changes in vehicle api
+
+## 3.21.1
+
+### Patch Changes
+
+- c57cd80: update utils package version
+
 ## 3.21.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -2014,6 +2014,14 @@ declare function useBuildingService(): {
     uploadSpreadsheetBuilding: (data: any[], site: string) => Promise<{
         buildingPayloads: any[];
         buildingUnitPayloads: any[];
+        insertedBuildings: number;
+        insertedUnits: number;
+        skippedRows: {
+            row: number;
+            block: number;
+            name: string;
+            reason: string;
+        }[];
     }>;
 };
 

package/dist/index.js

@@ -24143,6 +24143,7 @@ function useDahuaService() {
     return match ? match[1] : null;
   }
   async function addPlateNumber(value) {
+    console.log("addPlateNumber called with value:", value);
     let recno = null;
     const validation = import_joi40.default.object({
       host: import_joi40.default.string().required(),
@@ -24160,7 +24161,7 @@ function useDahuaService() {
       throw new import_node_server_utils72.BadRequestError(`Validation error: ${validationError.message}`);
     }
     try {
-      value.owner = String(value.owner ?? "").substring(0, 15) || "unknown";
+      value.owner = String(value.owner ?? "").replace(/['"]/g, "").replace(/[\/\\]/g, " - ").substring(0, 15).trim() || "unknown";
       const formatDahuaDate2 = (dateStr, fallbackYearsAhead = 0) => {
         const date = dateStr ? new Date(dateStr) : /* @__PURE__ */ new Date();
         if (!dateStr) {
@@ -27027,58 +27028,25 @@ function useVehicleService() {
           for (const camera of siteCameras) {
             const { host, username, password } = camera;
             const plateNumber2 = vehicleValue.plateNumber;
-            const dahuaQuery = {
+            const dahuaPayload = {
               host,
               username,
               password,
               plateNumber: plateNumber2,
-              mode: _mode
+              mode: _mode,
+              owner,
+              ...startDateDahua ? { start: startDateDahua } : {},
+              ...endDateDahua ? { end: endDateDahua } : {}
             };
-            const raw = await _getPlateNumber(dahuaQuery);
-            const parsed = parseDahuaFind(raw);
-            if (!parsed.exists) {
-              const dahuaPayload = {
-                host,
-                username,
-                password,
-                plateNumber: plateNumber2,
-                mode: _mode,
-                owner,
-                ...startDateDahua ? { start: startDateDahua } : {},
-                ...endDateDahua ? { end: endDateDahua } : {}
-              };
-              const dahuaResponse = await _addPlateNumber(dahuaPayload);
-              const responseStatus = dahuaResponse?.statusCode || dahuaResponse?.status || dahuaResponse?.res?.status || "unknown";
-              const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
-              if (responseStatus !== 200) {
-                throw new import_node_server_utils78.BadRequestError(
-                  `Failed to add plate number to ANPR ${_type}: status=${responseStatus}, response=${responseData}`
-                );
-              }
-              vehicleValue.recNo = responseData.split("=")[1]?.trim();
-            } else {
-              const dahuaPayload = {
-                host,
-                username,
-                password,
-                plateNumber: plateNumber2,
-                recno: parsed.recNo,
-                mode: _mode,
-                ...startDateDahua ? { start: startDateDahua } : {},
-                ...endDateDahua ? { end: endDateDahua } : {},
-                owner,
-                isOpenGate: true
-              };
-              const dahuaResponse = await _updatePlateNumber(dahuaPayload);
-              const responseStatus = dahuaResponse?.statusCode || dahuaResponse?.status || dahuaResponse?.res?.status || "unknown";
-              const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
-              if (responseStatus !== 200) {
-                throw new import_node_server_utils78.BadRequestError(
-                  `Failed to update plate number to ANPR ${_type}: status=${responseStatus}, response=${responseData}`
-                );
-              }
-              vehicleValue.recNo = parsed.recNo;
+            const dahuaResponse = await _addPlateNumber(dahuaPayload);
+            const responseStatus = dahuaResponse?.statusCode || dahuaResponse?.status || dahuaResponse?.res?.status || "unknown";
+            const responseData = dahuaResponse?.data?.toString("utf-8") ?? "";
+            if (responseStatus !== 200) {
+              throw new import_node_server_utils78.BadRequestError(
+                `Failed to add plate number to ANPR ${_type}: status=${responseStatus}, response=${responseData}`
+              );
             }
+            vehicleValue.recNo = responseData.split("=")[1]?.trim();
             if (value.peopleId && vehicleValue.recNo) {
               await _pushVehicleById(
                 value.peopleId,
@@ -28609,10 +28577,22 @@ function useBuildingRepo() {
         {
           $lookup: {
             from: "building-levels",
-            localField: "levels",
-            foreignField: "_id",
+            let: {
+              buildingId: "$_id",
+              buildingLevelIds: { $ifNull: ["$levels", []] }
+            },
             pipeline: [
-              { $match: { status: "active" /* ACTIVE */ } },
+              {
+                $match: {
+                  status: "active" /* ACTIVE */,
+                  $expr: {
+                    $or: [
+                      { $in: ["$_id", "$$buildingLevelIds"] },
+                      { $eq: ["$blockId", "$$buildingId"] }
+                    ]
+                  }
+                }
+              },
               { $project: { _id: 1, name: 1 } }
             ],
             as: "levels"
@@ -29179,6 +29159,12 @@ function useBuildingLevelRepo() {
         message: `Failed to clear cache namespace for ${building_level_namespace_collection}: ${err.message}`
       });
     });
+    delBuildingNamespace().catch((err) => {
+      import_node_server_utils87.logger.log({
+        level: "error",
+        message: `Failed to clear buildings cache: ${err.message}`
+      });
+    });
   }
   async function add(value, session) {
     try {
@@ -29378,12 +29364,6 @@ function useBuildingLevelRepo() {
         { session }
       );
       delCachedData();
-      delBuildingNamespace().catch((err) => {
-        import_node_server_utils87.logger.log({
-          level: "error",
-          message: `Failed to clear buildings cache: ${err.message}`
-        });
-      });
       return "Successfully deleted building level";
     } catch (error) {
       import_node_server_utils87.logger.log({
@@ -29546,6 +29526,18 @@ function useBuildingService() {
   const { updateStatusById } = useFileRepo();
   const { deleteFile } = useFileService();
   const { bulkWriteLevels: _bulkWriteLevels } = useBuildingLevelRepo();
+  function normalizeImportKey(value) {
+    return String(value ?? "").trim().replace(/\s+/g, " ").toLowerCase();
+  }
+  function toObjectIdOrNull(value) {
+    if (value instanceof import_mongodb54.ObjectId) {
+      return value;
+    }
+    if (typeof value === "string" && import_mongodb54.ObjectId.isValid(value)) {
+      return new import_mongodb54.ObjectId(value);
+    }
+    return null;
+  }
   async function add(value) {
     const session = import_node_server_utils88.useAtlas.getClient()?.startSession();
     if (!session) {
@@ -29688,47 +29680,161 @@ function useBuildingService() {
   }
   async function uploadSpreadsheetBuilding(data, site) {
     const session = import_node_server_utils88.useAtlas.getClient()?.startSession();
+    const db = import_node_server_utils88.useAtlas.getDb();
     if (!session) {
       throw new import_node_server_utils88.BadRequestError("Database session not available.");
     }
+    if (!db) {
+      throw new import_node_server_utils88.BadRequestError("Database not available.");
+    }
     try {
       session.startTransaction();
       const blockMap = /* @__PURE__ */ new Map();
+      const skippedRows = [];
       for (const row of data) {
         const block = row.block;
         const name = row.name;
+        const rowNumber = row.__rowNumber;
         const rawLevel = row.level?.toString().trim();
         const rawUnit = row.unit?.toString().trim();
         const normalizedLevel = /^(na|n\/a)$/i.test(rawLevel) ? null : rawLevel;
         const normalizedUnit = /^(na|n\/a)$/i.test(rawUnit) ? null : rawUnit;
         if (!blockMap.has(block)) {
-          blockMap.set(block, { name, levels: [], unitsByLevel: /* @__PURE__ */ new Map() });
+          blockMap.set(block, {
+            name,
+            levels: [],
+            rows: [],
+            unitsByLevel: /* @__PURE__ */ new Map(),
+            unitRowsByLevel: /* @__PURE__ */ new Map()
+          });
         }
         const blockEntry = blockMap.get(block);
+        blockEntry.rows.push(rowNumber);
         if (blockEntry.name !== name) {
           blockEntry.name = `${blockEntry.name}, ${name}`;
         }
-        if (normalizedLevel && !blockEntry.levels.includes(normalizedLevel)) {
+        if (normalizedLevel && !blockEntry.levels.some(
+          (level) => normalizeImportKey(level) === normalizeImportKey(normalizedLevel)
+        )) {
           blockEntry.levels.push(normalizedLevel);
         }
         if (normalizedLevel && normalizedUnit) {
           if (!blockEntry.unitsByLevel.has(normalizedLevel)) {
             blockEntry.unitsByLevel.set(normalizedLevel, []);
           }
+          if (!blockEntry.unitRowsByLevel.has(normalizedLevel)) {
+            blockEntry.unitRowsByLevel.set(normalizedLevel, /* @__PURE__ */ new Map());
+          }
           const units = blockEntry.unitsByLevel.get(normalizedLevel);
-          if (!units.includes(normalizedUnit)) {
+          const unitRows = blockEntry.unitRowsByLevel.get(normalizedLevel);
+          if (!units.some(
+            (unit) => normalizeImportKey(unit) === normalizeImportKey(normalizedUnit)
+          )) {
             units.push(normalizedUnit);
           }
+          unitRows.set(normalizedUnit, [
+            ...unitRows.get(normalizedUnit) ?? [],
+            rowNumber
+          ]);
         }
       }
       const buildingPayloads = [];
       const buildingUnitPayloads = [];
+      if (blockMap.size === 0) {
+        await session.commitTransaction();
+        return {
+          buildingPayloads,
+          buildingUnitPayloads,
+          insertedBuildings: 0,
+          insertedUnits: 0,
+          skippedRows
+        };
+      }
+      const buildingsCollection = db.collection(buildings_namespace_collection);
+      const buildingLevelsCollection = db.collection(
+        building_level_namespace_collection
+      );
+      const buildingUnitsCollection = db.collection(
+        building_units_namespace_collection
+      );
+      const existingBuildings = await buildingsCollection.find(
+        {
+          site: new import_mongodb54.ObjectId(site),
+          status: "active" /* ACTIVE */,
+          $or: Array.from(blockMap.entries()).flatMap(([block, entry]) => [
+            { block },
+            { name: entry.name }
+          ])
+        },
+        { session, projection: { block: 1, name: 1, levels: 1 } }
+      ).toArray();
+      const existingBuildingsByBlock = new Map(
+        existingBuildings.map((building) => [building.block, building])
+      );
+      const existingBuildingsByName = new Map(
+        existingBuildings.map((building) => [building.name, building])
+      );
+      const uploadedNames = /* @__PURE__ */ new Set();
       for (const [
         block,
-        { name, levels, unitsByLevel }
+        { name, levels, rows, unitsByLevel, unitRowsByLevel }
       ] of blockMap.entries()) {
-        const buildingId = new import_mongodb54.ObjectId();
-        const levelsPayload = (levels ?? []).map((levelName) => ({
+        const conflictReasons = [];
+        const existingBuildingByBlock = existingBuildingsByBlock.get(block);
+        const existingBuildingByName = existingBuildingsByName.get(name);
+        if (existingBuildingByBlock && existingBuildingByBlock.name !== name) {
+          conflictReasons.push(
+            `Block ${block} already exists with building name "${existingBuildingByBlock.name}".`
+          );
+        }
+        if (existingBuildingByName && existingBuildingByName.block !== block) {
+          conflictReasons.push(
+            `Building name "${name}" already exists in block ${existingBuildingByName.block}.`
+          );
+        }
+        if (uploadedNames.has(name)) {
+          conflictReasons.push(
+            `Building name "${name}" is duplicated in this spreadsheet.`
+          );
+        }
+        if (conflictReasons.length) {
+          rows.forEach((row) => {
+            skippedRows.push({
+              row,
+              block,
+              name,
+              reason: conflictReasons.join(" ")
+            });
+          });
+          continue;
+        }
+        uploadedNames.add(name);
+        const existingBuilding = existingBuildingByBlock ?? null;
+        const buildingId = existingBuilding?._id ?? new import_mongodb54.ObjectId();
+        const existingLevelIds = (existingBuilding?.levels ?? []).map(toObjectIdOrNull).filter(
+          (levelId) => Boolean(levelId)
+        );
+        const existingLevels = existingBuilding || existingLevelIds.length > 0 ? await buildingLevelsCollection.find(
+          {
+            $or: [
+              { blockId: buildingId },
+              { blockId: buildingId.toString() },
+              ...existingLevelIds.length > 0 ? [{ _id: { $in: existingLevelIds } }] : []
+            ],
+            status: "active" /* ACTIVE */
+          },
+          { session, projection: { name: 1 } }
+        ).toArray() : [];
+        const levelNameToId = new Map(
+          existingLevels.map((level) => [
+            normalizeImportKey(level.name),
+            level._id
+          ])
+        );
+        const missingLevels = (levels ?? []).filter(
+          (levelName) => !levelNameToId.has(normalizeImportKey(levelName))
+        );
+        const levelsPayload = missingLevels.map((levelName) => ({
           blockId: buildingId.toString(),
           site: site.toString(),
           name: levelName,
@@ -29741,23 +29847,80 @@ function useBuildingService() {
         if (levelsPayload.length > 0) {
           insertedLevels = await _bulkWriteLevels(levelsPayload, session);
         }
-        const levelNameToId = /* @__PURE__ */ new Map();
         if (insertedLevels) {
           insertedLevels.levels.forEach((lvl) => {
-            levelNameToId.set(lvl.name, lvl._id);
+            levelNameToId.set(normalizeImportKey(lvl.name), lvl._id);
           });
         }
-        const buildingPayload = {
-          _id: buildingId,
-          site,
-          block,
-          name,
-          levels: insertedLevels ? Object.values(insertedLevels.insertedIds) : []
-        };
-        const buildingResult = await _add(buildingPayload, session);
+        const levelIds = Array.from(levelNameToId.values());
+        if (existingBuilding) {
+          if (insertedLevels) {
+            await _updateById(
+              buildingId,
+              {
+                levels: [
+                  ...existingLevelIds,
+                  ...Object.values(insertedLevels.insertedIds)
+                ]
+              },
+              session
+            );
+          }
+        } else {
+          const buildingPayload = {
+            _id: buildingId,
+            site,
+            block,
+            name,
+            levels: levelIds
+          };
+          const buildingResult = await _add(buildingPayload, session);
+          buildingPayloads.push({ ...buildingPayload, _id: buildingResult });
+        }
+        const existingUnits = levelIds.length > 0 ? await buildingUnitsCollection.find(
+          {
+            building: { $in: [buildingId, buildingId.toString()] },
+            level: {
+              $in: [
+                ...levelIds,
+                ...levelIds.map((levelId) => levelId.toString())
+              ]
+            }
+          },
+          { session, projection: { name: 1, level: 1 } }
+        ).toArray() : [];
+        const existingUnitKeys = new Set(
+          existingUnits.map(
+            (unit) => `${unit.level.toString()}::${normalizeImportKey(unit.name)}`
+          )
+        );
         Array.from(unitsByLevel.entries()).forEach(([levelName, units]) => {
-          const levelId = levelNameToId.get(levelName);
+          const levelId = levelNameToId.get(normalizeImportKey(levelName));
+          if (!levelId)
+            return;
           units.forEach((unit) => {
+            const unitKey = `${levelId.toString()}::${normalizeImportKey(unit)}`;
+            const unitRows = unitRowsByLevel.get(levelName)?.get(unit) ?? rows;
+            if (existingUnitKeys.has(unitKey)) {
+              unitRows.forEach((row) => {
+                skippedRows.push({
+                  row,
+                  block,
+                  name,
+                  reason: `Unit "${unit}" already exists in level "${levelName}".`
+                });
+              });
+              return;
+            }
+            existingUnitKeys.add(unitKey);
+            unitRows.slice(1).forEach((row) => {
+              skippedRows.push({
+                row,
+                block,
+                name,
+                reason: `Unit "${unit}" is duplicated in this spreadsheet for level "${levelName}".`
+              });
+            });
             buildingUnitPayloads.push({
               site: new import_mongodb54.ObjectId(site),
               name: unit,
@@ -29783,9 +29946,17 @@ function useBuildingService() {
           });
         });
       }
-      await _bulkAddBuildingUnits(buildingUnitPayloads);
+      if (buildingUnitPayloads.length > 0) {
+        await _bulkAddBuildingUnits(buildingUnitPayloads, session);
+      }
       await session.commitTransaction();
-      return { buildingPayloads, buildingUnitPayloads };
+      return {
+        buildingPayloads,
+        buildingUnitPayloads,
+        insertedBuildings: buildingPayloads.length,
+        insertedUnits: buildingUnitPayloads.length,
+        skippedRows
+      };
     } catch (error) {
       await session.abortTransaction();
       throw error;
@@ -29807,6 +29978,19 @@ var import_joi46 = __toESM(require("joi"));
 var import_exceljs = __toESM(require("exceljs"));
 var import_csv_parser = __toESM(require("csv-parser"));
 var import_fs3 = __toESM(require("fs"));
+function normalizeSpreadsheetHeader(header) {
+  let value = "";
+  if (header && typeof header === "object" && "richText" in header && Array.isArray(header.richText)) {
+    value = header.richText.map((part) => part.text ?? "").join("");
+  } else if (header && typeof header === "object" && "text" in header) {
+    value = String(header.text ?? "");
+  } else if (header && typeof header === "object" && "result" in header) {
+    value = String(header.result ?? "");
+  } else {
+    value = String(header ?? "");
+  }
+  return value.replace(/^\uFEFF/, "").trim().replace(/\(.*\)/, "").trim().toLowerCase();
+}
 function useBuildingController() {
   const {
     getAll: _getAll,
@@ -30059,12 +30243,14 @@ function useBuildingController() {
       }
       const { originalname, path: path5 } = req.file;
       const lowerName = originalname.toLowerCase();
+      const expectedHeaders = ["block", "name", "level", "unit"];
+      const requiredFields = ["block", "name"];
       const rowSchema = import_joi46.default.object({
         block: import_joi46.default.number().integer().min(0).required(),
+        name: import_joi46.default.string().trim().required(),
         level: import_joi46.default.alternatives().try(import_joi46.default.string(), import_joi46.default.number()).custom((value) => String(value)).optional().allow(null, ""),
         unit: import_joi46.default.alternatives().try(import_joi46.default.string(), import_joi46.default.number()).custom((value) => String(value)).optional().allow(null, ""),
         category: import_joi46.default.string().trim().optional().allow(null, ""),
-        name: import_joi46.default.string().trim().optional().allow(null, ""),
         email: import_joi46.default.string().email().lowercase().optional().allow(null, ""),
         phoneNumber: import_joi46.default.string().trim().optional().allow(null, "")
       });
@@ -30095,9 +30281,18 @@ function useBuildingController() {
           return;
         }
         const headerRow = worksheet.getRow(1);
-        const headers = (headerRow.values || []).slice(1).map(
-          (header) => String(header ?? "").trim().replace(/\(.*\)/, "").trim()
+        const headers = (headerRow.values || []).slice(1).map((header) => normalizeSpreadsheetHeader(header));
+        const missingHeaders = expectedHeaders.filter(
+          (expected) => !headers.some((h) => h === expected)
         );
+        if (missingHeaders.length > 0) {
+          next(
+            new import_node_server_utils89.BadRequestError(
+              `Invalid Excel format. Missing required columns: ${missingHeaders.join(", ")}. Expected columns: ${expectedHeaders.join(", ")}`
+            )
+          );
+          return;
+        }
         worksheet.eachRow((row, rowNumber) => {
           if (rowNumber === 1)
             return;
@@ -30116,10 +30311,30 @@ function useBuildingController() {
           const parsed = [];
           import_fs3.default.createReadStream(path5).pipe(
             (0, import_csv_parser.default)({
-              mapHeaders: ({ header }) => header.trim().replace(/\(.*\)/, "").trim()
+              mapHeaders: ({ header }) => normalizeSpreadsheetHeader(header)
             })
-          ).on("data", (row) => parsed.push(row)).on("end", () => resolve(parsed)).on("error", reject);
+          ).on("data", (row) => {
+            if (Object.values(row).some(
+              (v) => v !== "" && v !== null && v !== void 0
+            )) {
+              parsed.push(row);
+            }
+          }).on("end", () => resolve(parsed)).on("error", reject);
         });
+        if (rows.length > 0) {
+          const csvHeaders = Object.keys(rows[0]);
+          const missingHeaders = expectedHeaders.filter(
+            (expected) => !csvHeaders.some((h) => h === expected)
+          );
+          if (missingHeaders.length > 0) {
+            next(
+              new import_node_server_utils89.BadRequestError(
+                `Invalid CSV format. Missing required columns: ${missingHeaders.join(", ")}. Expected columns: ${expectedHeaders.join(", ")}`
+              )
+            );
+            return;
+          }
+        }
       } else {
         next(
           new import_node_server_utils89.BadRequestError("Only .xlsx, .xls, or .csv files are allowed.")
@@ -30129,6 +30344,23 @@ function useBuildingController() {
       const validRows = [];
       const invalidRows = [];
       rows.forEach((row, index) => {
+        const emptyCells = Object.entries(row).filter(
+          ([, value2]) => value2 === "" || value2 === null || value2 === void 0
+        ).map(([key]) => key);
+        const emptyRequiredFields = emptyCells.filter(
+          (cell) => requiredFields.includes(cell)
+        );
+        if (emptyRequiredFields.length > 0) {
+          invalidRows.push({
+            row: index + 2,
+            // +2 because header is row 1
+            data: row,
+            errors: [
+              `Required field(s) empty: ${emptyRequiredFields.join(", ")}`
+            ]
+          });
+          return;
+        }
         const { error, value } = rowSchema.validate(row, {
           abortEarly: false,
           stripUnknown: true
@@ -30141,19 +30373,64 @@ function useBuildingController() {
             errors: error.details.map((d) => d.message)
           });
         } else {
-          validRows.push(value);
+          validRows.push({ ...value, __rowNumber: index + 2 });
         }
       });
-      await _uploadSpreadsheetBuilding(validRows, site);
+      let result;
+      try {
+        result = await _uploadSpreadsheetBuilding(validRows, site);
+      } catch (uploadError) {
+        import_node_server_utils89.logger.log({
+          level: "error",
+          message: `Upload error: ${uploadError.message}`
+        });
+        result = {
+          insertedBuildings: 0,
+          insertedUnits: 0,
+          skippedRows: [
+            {
+              rowNumber: "all",
+              reason: "Critical Upload Error",
+              error: uploadError.message
+            }
+          ]
+        };
+      }
+      const allSkippedItems = [
+        ...invalidRows.map((item) => ({
+          rowNumber: item.row,
+          reason: "Validation Error",
+          errors: item.errors,
+          data: item.data
+        })),
+        ...(result.skippedRows || []).map((item) => ({
+          rowNumber: "row" in item ? item.row : item.rowNumber,
+          reason: item.reason,
+          block: "block" in item ? item.block : void 0,
+          name: "name" in item ? item.name : void 0,
+          data: item
+        }))
+      ].sort((a, b) => {
+        if (typeof a.rowNumber === "string")
+          return 1;
+        if (typeof b.rowNumber === "string")
+          return -1;
+        return a.rowNumber - b.rowNumber;
+      });
+      const skippedSummary = allSkippedItems.map((item, idx) => `${idx + 1}. Row ${item.rowNumber}: ${item.reason}`).join("\n");
       res.status(200).json({
-        message: "Spreadsheet import completed (buildings).",
+        message: `Spreadsheet import completed (buildings).${allSkippedItems.length > 0 ? "\n\nSkipped items:\n" + skippedSummary : ""}`,
         fileName: originalname,
         totalRows: rows.length,
         validRows: validRows.length,
         invalidRows: invalidRows.length,
+        insertedBuildings: result.insertedBuildings,
+        insertedUnits: result.insertedUnits,
+        skippedRows: allSkippedItems.length,
         validationErrors: invalidRows,
-        data: validRows
-        // testing: return the validated building rows directly
+        skippedErrors: result.skippedRows,
+        skippedItemsSummary: allSkippedItems,
+        data: result
       });
       import_fs3.default.unlink(path5, () => {
       });