@bitpoolos/edge-bacnet 1.5.2 → 1.6.0

package/bacnet_read.html

@@ -545,6 +545,12 @@
             menu.style.setProperty("--mouse-x", event.clientX + "px");
             menu.style.setProperty("--mouse-y", event.clientY + "px");
             menu.style.display = "block";
+
+            if (app.rightClickedDevice.node.showAdded == true) {
+              menu.classList.add("deviceAddedToRead");
+            } else if (app.rightClickedDevice.node.showAdded == false) {
+              menu.classList.remove("deviceAddedToRead");
+            }
           },
           onPointRightClick(slotProps, event) {
             let app = this;
@@ -553,6 +559,12 @@
             pointMenu.style.setProperty("--mouse-x", event.clientX + "px");
             pointMenu.style.setProperty("--mouse-y", event.clientY + "px");
             pointMenu.style.display = "block";
+
+            if (app.rightClickedPoint.node.showAdded == true) {
+              pointMenu.classList.add("pointAddedToRead");
+            } else if (app.rightClickedPoint.node.showAdded == false) {
+              pointMenu.classList.remove("pointAddedToRead");
+            }
           },
           handleContextMenuClick(type) {
             let app = this;
@@ -593,55 +605,34 @@
           },
           purgeDevice(slotProps) {
             let app = this;
-            let device = app.deviceList.find((ele) => {
-              if (ele.address.address) {
-                return ele.address.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              } else {
-                return ele.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              }
-            });
+            let device = app.getDeviceFromDeviceList(slotProps.node.ipAddr, slotProps.node.deviceId);
             if (device) {
-              app.nodeService.purgeDevice(device).then(function (result) { });
+              app.nodeService.purgeDevice(device).then(function (result) {});
             }
           },
           updatePointsForDevice(slotProps) {
             let app = this;
-            let device = app.deviceList.find((ele) => {
-              if (ele.address.address) {
-                return ele.address.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              } else {
-                return ele.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              }
-            });
+            let device = app.getDeviceFromDeviceList(slotProps.node.ipAddr, slotProps.node.deviceId);
             if (device) {
-              app.nodeService.updatePointsForDevice(device).then(function (result) { });
+              app.nodeService.updatePointsForDevice(device).then(function (result) {});
             }
           },
           updatePoint(slotProps) {
             let app = this;
-            let device = app.deviceList.find((ele) => {
-              if (ele.address.address) {
-                return ele.address.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              } else {
-                return ele.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              }
+            const pointKey = `${slotProps.node.bacnetType}:${slotProps.node.bacnetInstance}`;
+            const device = app.deviceList.find((ele) => {
+              return ele.displayName == slotProps.node.parentDevice;
             });
+            const deviceKey = `${app.getDeviceAddress(device.address)}-${device.deviceId}`;
             if (device) {
-              app.nodeService.updatePoint(device).then(function (result) { });
+              app.nodeService.updatePoint(deviceKey, pointKey).then(function (result) {});
             }
           },
           setDeviceName() {
             let app = this;
             const slotProps = app.rightClickedDevice;
             const displayName = app.deviceDisplayNameValue;
-            let device = app.deviceList.find((ele) => {
-              if (ele.address.address) {
-                return ele.address.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              } else {
-                return ele.address == slotProps.node.ipAddr && ele.deviceId == slotProps.node.deviceId;
-              }
-            });
-
+            let device = app.getDeviceFromDeviceList(slotProps.node.ipAddr, slotProps.node.deviceId);
             if (device) {
               app.nodeService.setDeviceDisplayName(device, displayName).then(function (result) {
                 if (result) {
@@ -660,7 +651,7 @@
             const pointName = slotProps.node.pointName;
 
             let device = app.deviceList.find((ele) => {
-              return ele.deviceName == slotProps.node.parentDevice;
+              return ele.displayName == slotProps.node.parentDevice;
             });
 
             if (device) {
@@ -676,6 +667,18 @@
 
             app.showPointNameDialog = false;
           },
+          getDeviceFromDeviceList(ip, id) {
+            let app = this;
+            let device = app.deviceList.find((ele) => {
+              if (ele.address.address) {
+                return ele.address.address == ip && ele.deviceId == id;
+              } else {
+                return ele.address == ip && ele.deviceId == id;
+              }
+            });
+
+            return device;
+          },
           settingDeviceName(slotProps) {
             let app = this;
             if (slotProps.node.settingDisplayName) {
@@ -709,11 +712,9 @@
                 (ele) => ele.ipAddr == key.split("-")[0] && ele.deviceId == key.split("-")[1]
               );
               let deviceName;
-
               if (readDevice) {
                 deviceName = readDevice.label;
               }
-
               exportJson[key] = {};
               if (deviceName) {
                 exportJson[key]["deviceName"] = deviceName;
@@ -725,9 +726,8 @@
                 let pointName = devicePoints[pointIndex];
                 let pointObject = device[pointName];
 
-                //formatting json payload, still in progress
-
-                if (pointObject) {
+                //formatting json payload
+                if (pointObject && pointName !== "deviceName") {
                   exportJson[key][pointName] = {
                     meta: pointObject.meta,
                     objectName: pointObject.objectName,
@@ -765,6 +765,7 @@
               let ip = key.split("-")[0];
               let id = key.split("-")[1];
               const importedDevice = pointsToRead[key];
+              //match only by IP, to handle case of mstp device
               let foundIndex = app.devices.findIndex((ele) => ele.ipAddr == ip);
 
               if (foundIndex !== -1) {
@@ -772,17 +773,11 @@
                 if (app.devices[foundIndex].deviceId == id) {
                   //found device
                   let treeDevice = app.devices[foundIndex];
-                  let device = app.deviceList.find((ele) => {
-                    if (ele.address.address) {
-                      return ele.address.address == ip && ele.deviceId == id;
-                    } else {
-                      return ele.address == ip && ele.deviceId == id;
-                    }
-                  });
+                  let device = app.getDeviceFromDeviceList(ip, id);
 
                   for (let pointName in importedDevice) {
                     let point = importedDevice[pointName];
-                    if (pointName == "deviceName") {
+                    if (pointName == "deviceName" && typeof point == "string") {
                       app.nodeService.setDeviceDisplayName(device, point);
                       treeDevice.label = point;
                     } else {
@@ -849,7 +844,7 @@
 
                     for (let pointName in importedDevice) {
                       let point = importedDevice[pointName];
-                      if (pointName == "deviceName") {
+                      if (pointName == "deviceName" && typeof point == "string") {
                         app.nodeService.setDeviceDisplayName(device, point);
                         mstpDevice.label = point;
                       } else {
@@ -878,7 +873,9 @@
                           } else {
                             // read device found, add point to existing
                             let pointIndex = app.readDevices[isDeviceInReadList].children[0].children.findIndex(
-                              (ele) => ele.data == point.objectName
+                              (ele) =>
+                                parseInt(ele.bacnetInstance) == parseInt(point.meta.objectId.instance) &&
+                                parseInt(ele.bacnetType) == parseInt(point.meta.objectId.type)
                             );
                             if (pointIndex == -1) {
                               app.readDevices[isDeviceInReadList].children[0].children.push(pointInTree);
@@ -1088,7 +1085,7 @@
         </a>
       </li>
       <li class="red-ui-menu-divider"></li>
-      <li class="context-menu-item" @click="handleContextMenuClick('setDeviceName')">
+      <li class="context-menu-item set-device-name-option" @click="handleContextMenuClick('setDeviceName')">
         <a class="red-ui-menu-label">
           <i class="pi pi-pencil context-menu-icon"></i>
           <span class="context-menu-item-text">Set Device Name</span>
@@ -1100,7 +1097,7 @@
     <!-- Start Point Context Menu -->
     <ul
       class="red-ui-menu red-ui-menu-dropdown red-ui-menu-dropdown-direction-right red-ui-menu-dropdown-noicons red-ui-menu-dropdown-submenus point-context-menu">
-      <li class="context-menu-item" @click="handlePointContextMenuClick('setPointName')">
+      <li class="context-menu-item set-point-name-option" @click="handlePointContextMenuClick('setPointName')">
         <a class="red-ui-menu-label">
           <i class="pi pi-pencil context-menu-icon"></i>
           <span class="context-menu-item-text">Set Point Name</span>
@@ -1495,4 +1492,4 @@
     <li><a href="https://wiki.bitpool.com/">wiki.bitpool.com</a> - find more documentation.</li>
     <li><a href="https://bacnet.org/">BACnet</a> - find more about the protocol.</li>
   </ul>
-</script>
+</script>

package/bacnet_read.js

@@ -1,9 +1,6 @@
 /*
   MIT License Copyright 2021, 2022 - Bitpool Pty Ltd
 */
-
-
-
 module.exports = function (RED) {
   const { ReadCommandConfig } = require('./common');
   const baEnum = require('./resources/node-bacstack-ts/dist/index.js').enum;

package/common.js

@@ -1,13 +1,12 @@
 /*
-  MIT License Copyright 2021, 2024 - Bitpool Pty Ltd
+  MIT License Copyright 2021, 2025 - Bitpool Pty Ltd
 */
 
-const { createLogger, format, transports } = require("winston");
 const { randomUUID } = require("crypto");
 const os = require("os");
-const { exec } = require("child_process");
 const baEnum = require("./resources/node-bacstack-ts/dist/index.js").enum;
 const fs = require("fs");
+const fs2 = require("fs").promises;
 
 class BacnetConfig {
   constructor(
@@ -102,8 +101,6 @@ class BacnetClientConfig {
   }
 }
 
-
-
 class ReadCommandConfig {
   constructor(pointsToRead, objectProperties, decimalPrecision) {
     this.pointsToRead = pointsToRead;
@@ -190,30 +187,12 @@ const roundDecimalPlaces = function (value, decimals) {
   return value;
 };
 
-const doNodeRedRestart = function () {
-  return new Promise(function (resolve, reject) {
-    try {
-      exec("restart", (error, stdout, stderr) => {
-        if (error) {
-          console.log(`Node-Red restart error: ${error.message}`);
-          reject(error.message);
-        }
-        if (stderr) {
-          console.log(`Node-Red restart stderr: ${stderr}`);
-          reject(stderr);
-        }
-        resolve(stdout);
-      });
-    } catch (e) {
-      console.log(`Node-Red restart error: ${e}`);
-      reject(e);
-    }
-  });
-};
-
 // STORE CONFIG FUNCTION ==========================================================
 //
 // ================================================================================
+
+/*
+
 async function Store_Config(data) {
   try {
     await fs.writeFile("edge-bacnet-datastore.cfg", data, { encoding: "utf8", flag: "w" }, (err) => {
@@ -226,18 +205,185 @@ async function Store_Config(data) {
   }
 }
 
+*/
+
+// refactor:
+
+let storeQueue = [];
+let isStoreProcessing = false;
+
+async function queueConfigStore(data) {
+  storeQueue.push(data);
+
+  if (!isStoreProcessing) {
+    isStoreProcessing = true;
+
+    while (storeQueue.length > 0) {
+      const nextData = storeQueue.pop(); // Get most recent data
+      storeQueue.length = 0; // Clear any accumulated data
+
+      await Store_Config(nextData);
+
+      // Add small delay between attempts
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
+    isStoreProcessing = false;
+  }
+}
+
+async function Store_Config(data) {
+  const mainFile = "edge-bacnet-datastore.cfg";
+  const tempFile = "edge-bacnet-datastore.cfg.tmp";
+  const backupFile = "edge-bacnet-datastore.cfg.bak";
+
+  try {
+    // First validate the JSON to ensure it's valid before writing
+    try {
+      JSON.parse(JSON.stringify(data));
+    } catch (jsonError) {
+      console.error("Invalid JSON data detected:", jsonError);
+      return false;
+    }
+
+    // Write to temporary file first
+    await fs2.writeFile(tempFile, JSON.stringify(data, null, 2), { encoding: "utf8" });
+
+    // Verify the temporary file is valid JSON
+    try {
+      const tempContent = await fs2.readFile(tempFile, "utf8");
+      JSON.parse(tempContent);
+    } catch (verifyError) {
+      console.error("Temporary file validation failed:", verifyError);
+      await fs2.unlink(tempFile).catch(() => {});
+      return false;
+    }
+
+    // Create backup of current file if it exists
+    try {
+      await fs2.access(mainFile);
+      await fs2.copyFile(mainFile, backupFile);
+    } catch (backupError) {
+      // If main file doesn't exist, no backup needed
+    }
+
+    // Atomic rename of temporary file to main file
+    await fs2.rename(tempFile, mainFile);
+    return true;
+  } catch (error) {
+    console.error("Store_Config error:", error);
+
+    // Cleanup temporary file if it exists
+    try {
+      await fs2.unlink(tempFile).catch(() => {});
+    } catch (cleanupError) {}
+
+    // If main file is corrupted and backup exists, restore from backup
+    try {
+      const backupExists = await fs2.access(backupFile).catch(() => false);
+      if (backupExists) {
+        await fs2.copyFile(backupFile, mainFile);
+        console.log("Restored from backup file");
+      }
+    } catch (restoreError) {
+      console.error("Failed to restore from backup:", restoreError);
+    }
+
+    return false;
+  }
+}
+
 // READ CONFIG SYNC FUNCTION ======================================================
 //
 // ================================================================================
+
 function Read_Config_Sync() {
-  var data = "{}";
+  const mainFile = "edge-bacnet-datastore.cfg";
+  const backupFile = "edge-bacnet-datastore.cfg.bak";
+  const defaultData = "{}";
+
   try {
-    data = fs.readFileSync("edge-bacnet-datastore.cfg", { encoding: "utf8", flag: "r" });
-  } catch (err) {
-    data = "{}";
-    Store_Config(data);
+    // Try to read the main file
+    let data = fsSync.readFileSync(mainFile, { encoding: "utf8" });
+
+    // Validate JSON
+    try {
+      JSON.parse(data);
+      return data;
+    } catch (jsonError) {
+      console.error("Main file contains invalid JSON, attempting backup recovery");
+
+      // Try to read backup file
+      try {
+        const backupData = fsSync.readFileSync(backupFile, { encoding: "utf8" });
+        JSON.parse(backupData); // Validate backup JSON
+
+        // Restore from backup
+        fsSync.copyFileSync(backupFile, mainFile);
+        console.log("Successfully restored from backup file");
+        return backupData;
+      } catch (backupError) {
+        console.error("Backup recovery failed, creating new file");
+        fsSync.writeFileSync(mainFile, defaultData, { encoding: "utf8" });
+        return defaultData;
+      }
+    }
+  } catch (error) {
+    console.error("Error reading config:", error);
+    fsSync.writeFileSync(mainFile, defaultData, { encoding: "utf8" });
+    return defaultData;
+  }
+}
+
+// refactor:
+
+async function Read_Config_Async() {
+  // todo rename function, not using sync
+  const mainFile = "edge-bacnet-datastore.cfg";
+  const backupFile = "edge-bacnet-datastore.cfg.bak";
+  const defaultData = "{}";
+
+  try {
+    // Try to read the main file
+    const data = await fs2.readFile(mainFile, { encoding: "utf8" });
+
+    // Validate JSON
+    try {
+      JSON.parse(data);
+
+      return data;
+    } catch (jsonError) {
+      console.error("Main file contains invalid JSON, attempting backup recovery");
+
+      // Try to read backup file
+      try {
+        const backupData = await fs2.readFile(backupFile, { encoding: "utf8" });
+        JSON.parse(backupData); // Validate backup JSON
+
+        // Restore from backup
+        await fs.copyFile(backupFile, mainFile);
+        console.log("Successfully restored from backup file");
+
+        console.log("log2");
+
+        return backupData;
+      } catch (backupError) {
+        console.error("Backup recovery failed, creating new file");
+        await Store_Config(defaultData);
+
+        console.log("log3");
+
+        return defaultData;
+      }
+    }
+  } catch (error) {
+    console.error("Error reading config:", error);
+    await Store_Config(defaultData);
+
+    console.log("log4");
+
+    return defaultData;
   }
-  return data;
 }
 
 // STORE CONFIG FUNCTION - BACNET SERVER ==========================================
@@ -250,7 +396,7 @@ async function Store_Config_Server(data) {
         //console.log("Store_Config_Server writeFile error: ", err);
       }
     });
-  } catch (err) { }
+  } catch (err) {}
 }
 
 // READ CONFIG SYNC FUNCTION - BACNET SERVER ======================================
@@ -288,12 +434,12 @@ function decodeBitArray(size, bits) {
     if (i == bits.length - 1) {
       return array;
     }
-  };
+  }
 }
 
 function getBacnetErrorString(classInt, codeInt) {
-  const classString = Object.keys(baEnum.ErrorClass).find(key => baEnum.ErrorClass[key] === classInt);
-  const codeString = Object.keys(baEnum.ErrorCode).find(key => baEnum.ErrorCode[key] === codeInt);
+  const classString = Object.keys(baEnum.ErrorClass).find((key) => baEnum.ErrorClass[key] === classInt);
+  const codeString = Object.keys(baEnum.ErrorCode).find((key) => baEnum.ErrorCode[key] === codeInt);
   return `BacnetError - Class:${classString} - Code:${codeString}`;
 }
 
@@ -309,7 +455,22 @@ function parseBacnetError(error) {
   }
 
   return err;
-};
+}
+function debounce(func, wait) {
+  let timeout;
+
+  return function (...args) {
+    const context = this;
+
+    // Clear the previous timeout
+    clearTimeout(timeout);
+
+    // Set a new timeout
+    timeout = setTimeout(() => {
+      func.apply(context, args);
+    }, wait);
+  };
+}
 
 module.exports = {
   BacnetConfig,
@@ -320,13 +481,15 @@ module.exports = {
   generateId,
   getIpAddress,
   roundDecimalPlaces,
-  doNodeRedRestart,
+  queueConfigStore,
   Store_Config,
   Read_Config_Sync,
+  Read_Config_Async,
   Store_Config_Server,
   Read_Config_Sync_Server,
   isNumber,
   decodeBitArray,
   parseBacnetError,
   getBacnetErrorString,
+  debounce,
 };