@bitpoolos/edge-bacnet 1.6.2 → 1.6.4

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);
 };

package/bacnet_inspector.js

@@ -61,9 +61,41 @@ module.exports = function (RED) {
       site_Name: false,
     };
 
+    // Function to update node status with combined information
+    function updateNodeStatus() {
+      // Calculate offline percentage for display
+      const totalPolledPoints = cachedData.onlineCount + cachedData.offlineCount;
+      const offlinePercentage = totalPolledPoints > 0 ?
+        Math.round((cachedData.offlineCount / totalPolledPoints) * 100) : 0;
+
+      // Build comprehensive status text
+      const statusParts = [];
+
+      // Add online/offline info if we have polled points
+      if (totalPolledPoints > 0) {
+        statusParts.push(`Online: ${cachedData.onlineCount}/${totalPolledPoints} (${100 - offlinePercentage}%)`);
+      }
+
+      // Add points to read info if we have read list
+      if (cachedData.totalUniqueReadCount > 0) {
+        statusParts.push(`Total Points: ${cachedData.totalUniqueReadCount}`);
+      }
+
+      // Fallback status if no data
+      if (statusParts.length === 0) {
+        statusParts.push("No data");
+      }
+
+      // Update node status
+      node.status({ text: statusParts.join(" | ") });
+    }
+
     // Initialize cache from flow context
     initializeCache();
 
+    // Set initial status
+    updateNodeStatus();
+
     function initializeCache() {
       let flow = context.flow;
 
@@ -187,21 +219,31 @@ module.exports = function (RED) {
       } else if (msg.type === "Read") {
         calculateCombinedReadList(node, msg);
         if (done) done();
-      } else if (msg.payload && msg.payload.error !== undefined && msg.payload.error !== "none") {
-        // bacnet error msg found
-        setErrorTopics(msg);
-        if (done) done();
       } else if (msg.payload && msg.topic) {
-        //regular bacnet output
+        //regular bacnet output (including those with errors)
         // Queue the message for batch processing instead of immediate processing
         messageQueue.push({ msg, send, done });
         if (messageQueue.length >= MAX_BATCH_SIZE) {
           processBatch();
         }
+
+        // Also handle error tracking for messages with errors or offline status
+        if ((msg.payload.error !== undefined && msg.payload.error !== "none") ||
+          (msg.payload.status !== undefined && msg.payload.status === "offline")) {
+          setErrorTopics(msg);
+        }
       } else if (msg.type === "sendMqttStats") {
         // Make sure we have the latest statBlock values before sending stats
         syncStatBlockWithWorkerResults().then(() => {
           let statBlock = node.statBlock;
+          let statCounts = node.statCounts || {};
+
+          // Calculate appropriate totals for percentage calculations
+          const readCount = statCounts.readCount || 0;
+          const discoveryCount = statCounts.discoveryCount || 0;
+          const totalDevices = statCounts.totalDevices || 1; // Fallback to 1 to prevent division by zero
+
+          // Send raw values
           for (let key in statBlock) {
             let value = statBlock[key];
             let keyText = key.toUpperCase();
@@ -211,6 +253,35 @@ module.exports = function (RED) {
             };
             node.send(newMsg);
           }
+
+          // Send percentage values
+          for (let key in statBlock) {
+            let rawValue = statBlock[key];
+            let percentage = 0;
+
+            // Calculate percentage based on appropriate denominator (rounded to 2 decimal places)
+            if (key === 'unmapped') {
+              // Unmapped points are from discovery list
+              percentage = discoveryCount > 0 ? Math.round((rawValue / discoveryCount) * 10000) / 100 : 0;
+            } else if (key === 'offlinePercentage') {
+              // Already a percentage, just round to 2 decimal places
+              percentage = Math.round(rawValue * 100) / 100;
+            } else if (key === 'deviceIdConflict') {
+              // Device conflicts as percentage of total devices
+              percentage = totalDevices > 0 ? Math.round((rawValue / totalDevices) * 10000) / 100 : 0;
+            } else {
+              // All other stats (ok, error, missing, warnings, moved, deviceIdChange) are based on read list
+              percentage = readCount > 0 ? Math.round((rawValue / readCount) * 10000) / 100 : 0;
+            }
+
+            let keyText = key.toUpperCase();
+            let percentageMsg = {
+              topic: `EDGE_DEVICE_${node.siteName}/BACNETSTATS/${keyText}PERCENTAGE`,
+              payload: percentage,
+            };
+            node.send(percentageMsg);
+          }
+
           if (done) done();
         });
 
@@ -419,6 +490,10 @@ module.exports = function (RED) {
               topicData.error = error;
               entryChanged = true;
             }
+            if (status !== undefined && topicData.status !== status) {
+              topicData.status = status;
+              entryChanged = true;
+            }
 
             if (entryChanged) {
               topicData.key = topicData.deviceID + ":" + topicData.objectType + ":" + topicData.objectInstance;
@@ -436,8 +511,8 @@ module.exports = function (RED) {
         dirtyFlags.offlinePercentage = true;
       }
 
-      // Update the node status
-      node.status({ text: "Points Online: " + cachedData.onlineCount + "/" + cachedData.totalUniquePolledCount });
+      // Update the node status with combined information
+      updateNodeStatus();
 
       // Periodically call getModelStats to keep model stats updated
       // Use a debounce pattern to avoid calling it too frequently
@@ -581,6 +656,7 @@ module.exports = function (RED) {
     function setErrorTopics(msg) {
       let topic = msg.topic;
       let error = msg.payload.error;
+      let status = msg.payload.status;
 
       // Extract properties only if they exist
       let deviceID = msg.payload.meta?.device?.deviceId;
@@ -595,7 +671,8 @@ module.exports = function (RED) {
           ? msg.payload.meta.device.address.address
           : msg.payload.meta?.device?.address;
 
-      if (error !== undefined && error !== "none") {
+      // Track entries with explicit errors or offline status
+      if ((error !== undefined && error !== "none") || (status !== undefined && status === "offline")) {
         // Use the cache instead of direct flow context access
         cachedData.entriesWithErrors.set(topic, {
           deviceID: deviceID,
@@ -605,7 +682,7 @@ module.exports = function (RED) {
           displayName: displayName,
           deviceName: deviceName,
           ipAddress: ipAddress,
-          error: error,
+          error: error || (status === "offline" ? "Point offline" : "N/A"),
         });
 
         // Mark as dirty so it will be synced to flow context
@@ -771,12 +848,11 @@ module.exports = function (RED) {
       // Force sync with flow context to ensure data is immediately available
       syncWithFlowContext();
 
-      // Update the node status
-      node.status({ text: "Points To Read: " + cachedData.totalUniqueReadCount });
+      // Update the node status with combined information
+      updateNodeStatus();
     }
 
     function getPublishedPointsList() {
-      node.warn("Generating Published Points List...");
       let flow = context.flow;
       let now = new Date();
 

package/bacnet_inspector_worker.js

@@ -149,6 +149,7 @@ function processModelStats(data) {
     // Store the data under all variations
     const publishData = {
       error: data.error || "N/A",
+      status: data.status || "N/A",
       presentValue: data.presentValue,
       bacnetLastSeen: data.bacnetLastSeen
     };
@@ -232,15 +233,24 @@ function processModelStats(data) {
 
     if (DiscoveryKeyMatch) {
       if (PublishPointTopicMatch) {
-        const error = PublishTopicsNormalized.get(matchVariation).error;
-        if (error !== "none" && error !== "N/A") {
-          PointResult.dataModelStatus = `Point Error - Matched in Discovery / Data Model and publishing, however BACNet Error is present: ${error}`;
+        const publishData = PublishTopicsNormalized.get(matchVariation);
+        const error = publishData.error;
+        const status = publishData.status;
+
+        // Check if point has error or is offline
+        if ((error !== "none" && error !== "N/A") || status === "offline") {
+          if (status === "offline") {
+            PointResult.dataModelStatus = `Point Error - Matched in Discovery / Data Model and publishing, however point status is offline`;
+          } else {
+            PointResult.dataModelStatus = `Point Error - Matched in Discovery / Data Model and publishing, however BACNet Error is present: ${error}`;
+          }
           statBlock.error++;
         } else {
           PointResult.dataModelStatus = "Point Ok - Matched in Discovery / Data Model and publishing";
           statBlock.ok++;
         }
         PointResult.error = error;
+        PointResult.status = status; // Also store the status for reference
         pointOkCount++;
       } else {
         if (DiscoveryPointMap[ReadPointKey].objectName !== ReadPointObj.pointName) {