@bitpoolos/edge-bacnet 1.6.2 → 1.6.3

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.6.3] - 00-06-2025
+
+Minor feature: 
+  - Device List - new right click option to MSTP NET folders - Update All Devices. Specifically updates the mstp device listed in that selected network 
+  - Inspector - Added statistic percentages as MQTT output in the Inspector node
+  - Inspector - Added online / offline stats and Total points to read as status on node
+  - Test Functions - Outputs results to both node-red console and node-red debug window now
+
+Minor update / refactor:
+  - Datamodel - Importing and Exporting datamodel displays process status and related stats (file size etc) while importing or exporting, informing the user of current state
+  - Device List - UI tree no longer stored in datamodel, as it is generated dynamically on a schedule. This significantly reduces datamodel file size, read / write time, system start up processes. 
+  - Datamodel - writes to file system for persistance and backup was being executed more often than needed. Process schedule is now on a larger interval, and write algorithm refactored and optimized. 
+  - Device List - right click -> Set Point Name feature refactored, due to many scenarios where it wasnt executing as expected.
+  - BACnet read output - error and status field setting optimized
+  - Inspector - updated ObjectType column values to show object type enum string instead of integer
+
+Bug fixes:
+  - Inspector - incorrect percentages, statistics and values in the statistics bar. Fixed and tested to represent site status more accurately 
+  - Inpsector - not flagging offline points in error statistic and table filter. Now correctly identifies "offline" points as an Error type
+  - BACnet read output - was not updating error and status correctly for full object payloads. 
+  - BACnet Server - was not outputting sucessfull write update MQTT msg after node-red deploy. 
+
+Updating: 
+  - There shouldnt be a need for users to remove nodes or do any specific action when updating to this version, however backing up a datamodel export is advised.
+
+
 ## [1.6.2] - 07-05-2025
 
 Minor feature: 

package/bacnet_client.js

@@ -20,6 +20,7 @@ const { BacnetDevice } = require("./bacnet_device");
 const { Mutex } = require("async-mutex");
 const { treeBuilder } = require("./treeBuilder.js");
 
+
 class BacnetClient extends EventEmitter {
   //client constructor
   constructor(config) {
@@ -28,6 +29,7 @@ class BacnetClient extends EventEmitter {
     that.config = config;
     that.deviceList = [];
     that.networkTree = {};
+    that.renderList = [];
     that.lastWhoIs = null;
     that.client = null;
     that.lastNetworkPoll = null;
@@ -201,7 +203,8 @@ class BacnetClient extends EventEmitter {
       const cachedData = await Read_Config_Async();
       const parsedData = JSON.parse(cachedData);
       if (parsedData && typeof parsedData == "object") {
-        if (parsedData.renderList) that.renderList = parsedData.renderList;
+        // renderList is no longer cached - will be rebuilt by tree builder
+        // if (parsedData.renderList) that.renderList = parsedData.renderList;
         if (parsedData.deviceList) {
           parsedData.deviceList.forEach(function (device) {
             let newBacnetDevice = new BacnetDevice(true, device);
@@ -209,12 +212,13 @@ class BacnetClient extends EventEmitter {
           });
         }
         if (parsedData.pointList) that.networkTree = parsedData.pointList;
-        if (parsedData.renderListCount) that.renderListCount = parsedData.renderListCount;
+        // renderListCount is no longer cached - will be recalculated by tree builder
+        // if (parsedData.renderListCount) that.renderListCount = parsedData.renderListCount;
       }
     }
   }
 
-  testFunction(address, port, type, instance, property) {
+  testFunction(address, port, type, instance, property, nodeWarnCallback) {
     let that = this;
     console.log("test function ");
 
@@ -229,6 +233,11 @@ class BacnetClient extends EventEmitter {
       console.log("1 - readPropertyMultiple:  ");
 
       console.log(value);
+
+      if (nodeWarnCallback) {
+        nodeWarnCallback(value);
+      }
+
       if (value) {
         // If the result has value, resolve the promise
         console.log(value.values[0]);
@@ -720,35 +729,30 @@ class BacnetClient extends EventEmitter {
     const that = this;
     const roundDecimal = readConfig.precision;
     const devicesToRead = Object.keys(readConfig.pointsToRead);
-    const bacnetResults = {};
-    let pendingRequests = 0;
+    let completedDevices = 0;
 
     try {
-      // Process all devices in sequence
-      for (let deviceIndex = 0; deviceIndex < devicesToRead.length; deviceIndex++) {
-        const key = devicesToRead[deviceIndex];
+      // Create array of device processing promises
+      const devicePromises = devicesToRead.map(async (key, deviceIndex) => {
         const device = that.findDeviceByKey(key);
-        if (!device) continue;
+        if (!device) return null;
 
         const deviceName = that.computeDeviceName(device);
         const deviceKey = that.createDeviceKey(device);
         const deviceObject = that.networkTree[deviceKey];
         const maxObjectCount = that.estimateMaxObjectSize(device.getMaxApdu());
 
-        if (!bacnetResults[deviceName]) {
-          bacnetResults[deviceName] = {};
-        }
+        const bacnetResults = {};
+        bacnetResults[deviceName] = {};
 
         // Process points for the current device
         const pointsToRead = readConfig.pointsToRead[key];
         const pointNames = Object.keys(pointsToRead);
         let totalPoints = pointNames.length - 1;
         let requestArray = [];
-        let processedPoints = 0; // Counter for processed points
 
         // Process each point for the device in batches
         for (let i = 0; i < pointNames.length; i++) {
-
           const pointName = pointNames[i];
           if (pointName === "deviceName") {
             continue;
@@ -771,7 +775,7 @@ class BacnetClient extends EventEmitter {
           }
 
           // Process the batch when the request array is full or the last point is reached
-          if (requestArray.length === maxObjectCount) {
+          if (requestArray.length === maxObjectCount || i === pointNames.length - 1) {
             if (device.getProtocolServiceSupport("ReadPropertyMultiple") == true) {
               await that.processBatch(device, requestArray, deviceName, bacnetResults, that, roundDecimal);
             } else {
@@ -779,38 +783,43 @@ class BacnetClient extends EventEmitter {
             }
 
             requestArray = [];
-            // Increment the processed points counter
-            processedPoints += maxObjectCount;
-          } else if (i === pointNames.length - 1) {
-            if (device.getProtocolServiceSupport("ReadPropertyMultiple") == true) {
-              await that.processBatch(device, requestArray, deviceName, bacnetResults, that, roundDecimal);
-            } else {
-              await that.processIndividualPoints(device, requestArray, deviceName, bacnetResults, that, roundDecimal);
-            }
-
-            requestArray = [];
-            // Increment the processed points counter
-            processedPoints += i;
           }
+        }
 
-          // Check if all points for the device have been processed
-          if (processedPoints >= totalPoints) {
-            pendingRequests++;
-
-            // Emit the `values` event for the current device
-            that.emit(
-              "values",
-              bacnetResults,
-              outputType,
-              objectPropertyType,
-              readNodeName,
-              pendingRequests,
-              devicesToRead.length
-            );
-            delete bacnetResults[deviceName];
-          }
+        // Return results for this device
+        return {
+          deviceName,
+          results: bacnetResults,
+          deviceIndex: deviceIndex + 1,
+          totalDevices: devicesToRead.length
+        };
+      });
+
+      // Process all devices in parallel and emit results as they complete
+      const results = await Promise.allSettled(devicePromises);
+
+      results.forEach((result, index) => {
+        if (result.status === 'fulfilled' && result.value) {
+          completedDevices++;
+          const { deviceName, results: bacnetResults, deviceIndex, totalDevices } = result.value;
+
+          // Emit the `values` event for this device immediately
+          that.emit(
+            "values",
+            bacnetResults,
+            outputType,
+            objectPropertyType,
+            readNodeName,
+            completedDevices,
+            totalDevices
+          );
+        } else {
+          // Handle failed device (offline/error)
+          completedDevices++;
+          that.logOut(`Device ${devicesToRead[index]} failed:`, result.reason);
         }
-      }
+      });
+
     } catch (error) {
       that.logOut("doRead error: ", error);
     }
@@ -847,6 +856,7 @@ class BacnetClient extends EventEmitter {
           if (isNumber(val)) {
             pointRef.presentValue = roundDecimalPlaces(val, roundDecimal);
             pointRef.error = "none";
+            pointRef.status = "online";
             if (pointRef.meta.objectId.type == 19 || pointRef.meta.objectId.type == 13 || pointRef.meta.objectId.type == 14) {
               if (pointRef.stateTextArray && typeof pointRef.stateTextArray[0].value !== "object") {
                 if (val != 0) {
@@ -860,14 +870,18 @@ class BacnetClient extends EventEmitter {
             if (typeof val !== "object") {
               pointRef.presentValue = val;
               pointRef.error = "none";
+              pointRef.status = "online";
             } else if (val.errorClass && val.errorClass) {
               pointRef.error = getBacnetErrorString(val.errorClass, val.errorClass);
+              pointRef.status = "offline";
+            } else {
+              pointRef.error = "none";
+              pointRef.status = "online";
             }
           }
 
           pointRef.meta["device"] = deviceMetaInfo;
           pointRef.timestamp = Date.now();
-          pointRef.status = "online";
 
           // Store the point data in results
           bacnetResults[deviceName][pointNameRef] = pointRef;
@@ -899,6 +913,8 @@ class BacnetClient extends EventEmitter {
 
           if (isNumber(val)) {
             pointRef.presentValue = roundDecimalPlaces(val, roundDecimal);
+            pointRef.error = "none";
+            pointRef.status = "online";
 
             if (pointRef.meta.objectId.type == 19 || pointRef.meta.objectId.type == 13 || pointRef.meta.objectId.type == 14) {
               if (pointRef.stateTextArray && typeof pointRef.stateTextArray[0].value !== "object") {
@@ -910,13 +926,21 @@ class BacnetClient extends EventEmitter {
               }
             }
           } else {
-            pointRef.presentValue = val;
+            if (typeof val !== "object") {
+              pointRef.presentValue = val;
+              pointRef.error = "none";
+              pointRef.status = "online";
+            } else if (val.errorClass && val.errorClass) {
+              pointRef.error = getBacnetErrorString(val.errorClass, val.errorClass);
+              pointRef.status = "offline";
+            } else {
+              pointRef.error = "none";
+              pointRef.status = "online";
+            }
           }
 
           pointRef.meta["device"] = deviceMetaInfo;
           pointRef.timestamp = Date.now();
-          pointRef.status = "online";
-          pointRef.error = "none";
 
           // Store the point data in results
           bacnetResults[deviceName][pointName] = pointRef;
@@ -1681,7 +1705,7 @@ class BacnetClient extends EventEmitter {
         if (json.body.renderListCount) {
           that.renderListCount = json.body.renderListCount;
         }
-        resolve();
+        resolve(true);
       } catch (e) {
         reject(e);
       }

package/bacnet_gateway.html

@@ -136,6 +136,16 @@
         body: JSON.stringify({ k: deviceKey, p: pointName, n: pointDisplayName }),
       }).then((res) => res.json());
     }
+    applyDisplayNames(pointsToRead) {
+      return fetch(RED.settings.httpNodeRoot + "bitpool-bacnet-data/applyDisplayNames", {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ pointsToRead: pointsToRead }),
+      }).then((res) => res.json());
+    }
     importReadList(payload) {
       return fetch(RED.settings.httpNodeRoot + "bitpool-bacnet-data/importReadList", {
         method: "POST",
@@ -396,25 +406,130 @@
         });
       });
 
+      function setDataModelUpdateStatus(status, type, autoClear) {
+        const statusElement = $("#data-model-update-status");
+        statusElement.text(status);
+
+        // Remove existing status classes
+        statusElement.removeClass("status-success status-error status-warning status-info");
+
+        // Add appropriate styling based on type
+        switch (type) {
+          case "success":
+            statusElement.addClass("status-success");
+            break;
+          case "error":
+            statusElement.addClass("status-error");
+            break;
+          case "warning":
+            statusElement.addClass("status-warning");
+            break;
+          case "info":
+          default:
+            statusElement.addClass("status-info");
+            break;
+        }
+
+        // Auto-clear success messages after 5 seconds
+        if (autoClear !== false && type === "success") {
+          setTimeout(() => {
+            statusElement.text("");
+            statusElement.removeClass("status-success");
+          }, 5000);
+        }
+      }
+
       //Import complete Data model
       $("#file-upload-database").on("change", function (event) {
         const input = event.target.files[0];
+
+        if (!input) {
+          setDataModelUpdateStatus("No file selected", "warning");
+          return;
+        }
+
+        // Validate file type
+        if (!input.name.toLowerCase().endsWith('.json')) {
+          setDataModelUpdateStatus("Please select a valid JSON file", "error");
+          return;
+        }
+
+        // Check file size (warn if larger than 10MB)
+        const fileSizeMB = (input.size / (1024 * 1024)).toFixed(2);
+        if (input.size > 10 * 1024 * 1024) {
+          setDataModelUpdateStatus(`Large file detected (${fileSizeMB}MB). Import may take several minutes...`, "warning");
+        }
+
+        // Confirmation dialog for potentially destructive operation
+        if (!confirm(`Are you sure you want to import this data model?\n\nFile: ${input.name}\nSize: ${fileSizeMB}MB\n\nThis will replace the existing data model and cannot be undone.`)) {
+          // Reset the file input
+          $(this).val('');
+          setDataModelUpdateStatus("Import cancelled", "info");
+          return;
+        }
+
         const reader = new FileReader();
 
-        reader.onload = function (e) {
-          const text = e.target.result;
+        reader.onloadstart = function () {
+          setDataModelUpdateStatus("Reading file...", "info");
+        };
 
-          let jsonPayload = JSON.parse(text);
+        reader.onprogress = function (e) {
+          if (e.lengthComputable) {
+            const percentLoaded = Math.round((e.loaded / e.total) * 100);
+            setDataModelUpdateStatus(`Reading file... ${percentLoaded}%`, "info");
+          }
+        };
 
-          $.ajax({
-            type: "POST",
-            url: RED.settings.httpNodeRoot + "bitpool-bacnet-data/updateDataModel",
-            dataType: "json",
-            contentType: "application/json",
-            data: JSON.stringify(jsonPayload),
-            success: function (result) { },
-            timeout: 0,
-          });
+        reader.onload = function (e) {
+          setDataModelUpdateStatus("Parsing JSON data...", "info");
+
+          try {
+            const text = e.target.result;
+            let jsonPayload = JSON.parse(text);
+
+            setDataModelUpdateStatus("Uploading data model to server...", "info");
+
+            $.ajax({
+              type: "POST",
+              url: RED.settings.httpNodeRoot + "bitpool-bacnet-data/updateDataModel",
+              dataType: "json",
+              contentType: "application/json",
+              data: JSON.stringify(jsonPayload),
+              success: function (data, status, xhr) {
+                setDataModelUpdateStatus(`Data model imported successfully! (${fileSizeMB}MB processed)`, "success");
+                // Clear the file input
+                $("#file-upload-database").val('');
+              },
+              error: function (xhr, status, error) {
+                let errorMsg = "Failed to import data model";
+                if (xhr.responseText) {
+                  try {
+                    const errorResponse = JSON.parse(xhr.responseText);
+                    errorMsg += ": " + (errorResponse.message || errorResponse.error || xhr.responseText);
+                  } catch (e) {
+                    errorMsg += ": " + xhr.responseText;
+                  }
+                } else {
+                  errorMsg += ": " + (error || status || "Unknown error");
+                }
+                setDataModelUpdateStatus(errorMsg, "error");
+                // Clear the file input
+                $("#file-upload-database").val('');
+              },
+              timeout: 0,
+            });
+          } catch (parseError) {
+            setDataModelUpdateStatus("Invalid JSON file: " + parseError.message, "error");
+            // Clear the file input
+            $("#file-upload-database").val('');
+          }
+        };
+
+        reader.onerror = function () {
+          setDataModelUpdateStatus("Error reading file", "error");
+          // Clear the file input
+          $("#file-upload-database").val('');
         };
 
         reader.readAsText(input);
@@ -422,16 +537,82 @@
 
       // Export complete Data model
       $("#file-export-database").click(function (params) {
+        // Confirmation dialog
+        if (!confirm("Are you sure you want to export the complete data model?\n\nThis may take some time for large databases.")) {
+          setDataModelUpdateStatus("Export cancelled", "info");
+          return;
+        }
+
+        setDataModelUpdateStatus("Retrieving data model from server...", "info");
+
+        const startTime = Date.now();
+
         $.ajax({
           url: RED.settings.httpNodeRoot + "bitpool-bacnet-data/getDataModel",
           success: function (deviceList) {
-            let data = "text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(deviceList));
-            let aEle = document.getElementById("exportJSON");
-            aEle.setAttribute("href", "data:" + data);
-            aEle.setAttribute("download", "edge-bacnet-datastore.json");
-            aEle.click();
+            try {
+              setDataModelUpdateStatus("Preparing download...", "info");
+
+              // Calculate data size
+              const jsonString = JSON.stringify(deviceList);
+              const dataSize = new Blob([jsonString]).size;
+              const dataSizeMB = (dataSize / (1024 * 1024)).toFixed(2);
+
+              // Create a Blob with the JSON data
+              const blob = new Blob([jsonString], { type: 'application/json' });
+
+              // Create an object URL from the Blob
+              const url = URL.createObjectURL(blob);
+
+              // Generate filename with timestamp
+              const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+              const filename = `edge-bacnet-datastore-${timestamp}.json`;
+
+              // Set the URL to the link and trigger download
+              let aEle = document.getElementById("exportJSON");
+              aEle.setAttribute("href", url);
+              aEle.setAttribute("download", filename);
+              aEle.click();
+
+              // Calculate duration
+              const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+              setDataModelUpdateStatus(`Export completed successfully! (${dataSizeMB}MB, ${duration}s)`, "success");
+
+              // Release the object URL when done
+              setTimeout(() => {
+                URL.revokeObjectURL(url);
+              }, 2000);
+
+            } catch (error) {
+              console.error("Error exporting data model:", error);
+              setDataModelUpdateStatus("Failed to create download file: " + error.message, "error");
+            }
           },
-          timeout: 0,
+          error: function (xhr, status, error) {
+            console.error("AJAX error retrieving data model:", status, error);
+            let errorMsg = "Failed to retrieve data model from server";
+
+            if (xhr.status === 0) {
+              errorMsg += " (Connection timeout or server unavailable)";
+            } else if (xhr.status === 404) {
+              errorMsg += " (Endpoint not found)";
+            } else if (xhr.status === 500) {
+              errorMsg += " (Internal server error)";
+            } else if (xhr.responseText) {
+              try {
+                const errorResponse = JSON.parse(xhr.responseText);
+                errorMsg += ": " + (errorResponse.message || errorResponse.error);
+              } catch (e) {
+                errorMsg += ": " + xhr.responseText;
+              }
+            } else {
+              errorMsg += ": " + (error || status || "Unknown error");
+            }
+
+            setDataModelUpdateStatus(errorMsg, "error");
+          },
+          timeout: 60000, // 60 second timeout for large exports
         });
       });
 
@@ -818,6 +999,39 @@
     .database-file-label-div {
       padding-top: 15px;
     }
+    /* Status indicator styles */
+    .status-success {
+      color: #28a745 !important;
+      font-weight: 500;
+      background-color: #d4edda;
+      border: 1px solid #c3e6cb;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
+    .status-error {
+      color: #dc3545 !important;
+      font-weight: 500;
+      background-color: #f8d7da;
+      border: 1px solid #f5c6cb;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
+    .status-warning {
+      color: #856404 !important;
+      font-weight: 500;
+      background-color: #fff3cd;
+      border: 1px solid #ffeaa7;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
+    .status-info {
+      color: #0c5460 !important;
+      font-weight: 500;
+      background-color: #d1ecf1;
+      border: 1px solid #bee5eb;
+      border-radius: 4px;
+      padding: 8px 12px;
+    }
   </style>
 
   <div class="form-row node-input-read-tabs-row">
@@ -1070,6 +1284,7 @@
         <input id="file-export-database" class="inputStyle" style="width: 258px; display: none;" />
         <a id="exportJSON" style="display: none"></a>
       </div>
+      <div id="data-model-update-status" class="data-model-update-status" style="margin-top: 10px;"></div>
     </div>
   </div>
 </script>

package/bacnet_gateway.js

@@ -215,11 +215,14 @@ module.exports = function (RED) {
     if (
       node.bacnetServerEnabled == true &&
       node.bacnetClient &&
-      node.bacnetServer &&
-      nodeContext.get("serverWritePropEvent") == false
+      node.bacnetServer
     ) {
       try {
-        node.bacnetServer.on("writeProperty", (topic, newValue) => {
+        // Clean up any existing listeners to prevent stale references
+        node.bacnetServer.removeAllListeners('writeProperty');
+
+        // Store the event handler function so we can clean it up later
+        node.writePropertyHandler = (topic, newValue) => {
           let formattedTopic = topic;
           if (
             node.nodeName !== "gateway" &&
@@ -234,8 +237,9 @@ module.exports = function (RED) {
           }
 
           node.send({ payload: newValue, topic: formattedTopic });
-        });
-        nodeContext.set("serverWritePropEvent", true);
+        };
+
+        node.bacnetServer.on("writeProperty", node.writePropertyHandler);
       } catch (e) {
         console.log("Bacnet gateway node server writePoperty error: ", e);
       }
@@ -270,7 +274,7 @@ module.exports = function (RED) {
               logOut("Error updating priorityQueue: ", error);
             });
         } else if (msg.testFunc == true) {
-          node.bacnetClient.testFunction(msg.address, msg.port, msg.type, msg.instance, msg.property);
+          node.bacnetClient.testFunction(msg.address, msg.port, msg.type, msg.instance, msg.property, nodeWarn);
         } else if (msg.applyDisplayNames) {
           node.status({ fill: "blue", shape: "dot", text: "Updating display names" });
           setTimeout(() => {
@@ -300,7 +304,14 @@ module.exports = function (RED) {
       });
 
       node.on("close", function () {
-        //do nothing
+        // Clean up the writeProperty event listener
+        if (node.bacnetServer && node.writePropertyHandler) {
+          node.bacnetServer.removeListener('writeProperty', node.writePropertyHandler);
+          node.writePropertyHandler = null;
+        }
+
+        // Reset the serverWritePropEvent flag so it can be re-registered
+        nodeContext.set("serverWritePropEvent", false);
       });
     } catch (e) {
       console.log("Bacnet node event handler error: ", e);
@@ -461,7 +472,7 @@ module.exports = function (RED) {
         node.bacnetClient
           .updateDataModel(req)
           .then(function (result) {
-            res.send(result);
+            res.send(true);
           })
           .catch(function (error) {
             res.send(error);
@@ -560,6 +571,24 @@ module.exports = function (RED) {
       }
     });
 
+    //route handler for applyDisplayNames
+    RED.httpAdmin.post("/bitpool-bacnet-data/applyDisplayNames", function (req, res) {
+      if (!node.bacnetClient) {
+        logOut("Issue with the bacnetClient while applying display names: ", node.bacnetClient);
+        res.send(false);
+      } else {
+        node.bacnetClient
+          .applyDisplayNames(req.body.pointsToRead)
+          .then(function (result) {
+            res.send(result);
+          })
+          .catch(function (error) {
+            res.send(error);
+            logOut("Error applying display names:  ", error);
+          });
+      }
+    });
+
     //route handler for importReadList
     RED.httpAdmin.post("/bitpool-bacnet-data/importReadList", function (req, res) {
       if (!node.bacnetClient) {
@@ -948,6 +977,10 @@ module.exports = function (RED) {
       }
       return pointName;
     }
+
+    function nodeWarn(message) {
+      node.warn(message);
+    }
   }
   RED.nodes.registerType("Bacnet-Gateway", BitpoolBacnetGatewayDevice);
 };