@bitpoolos/edge-bacnet 1.6.2 → 1.6.3

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) {

package/bacnet_read.html

@@ -62,6 +62,7 @@
             progressBarValue: ref(),
             rightClickedDevice: ref(),
             rightClickedPoint: ref(),
+            rightClickedMstpFolder: ref(),
             showDeviceNameDialog: ref(false),
             showPointNameDialog: ref(false),
             deviceDisplayNameValue: ref(),
@@ -288,7 +289,13 @@
                 newReadParent = JSON.parse(JSON.stringify(parentDevice));
               }
               newReadParent.children[0].children = [];
-              newReadParent.children[0].children.push(slotProps.node);
+
+              // Create a copy of the point with preserved display name
+              let pointCopy = JSON.parse(JSON.stringify(slotProps.node));
+              // Ensure display name is preserved from the original point
+              pointCopy.label = slotProps.node.label;
+              newReadParent.children[0].children.push(pointCopy);
+
               while (newReadParent.children.length > 1) {
                 newReadParent.children.forEach(function (child, index) {
                   if (child.label.includes("MSTP")) {
@@ -307,7 +314,10 @@
                 (ele) => ele.pointName == slotProps.node.pointName
               );
               if (pointIndex == -1) {
-                this.readDevices[foundDeviceIndex].children[0].children.push(slotProps.node);
+                // Create a copy of the point with preserved display name
+                let pointCopy = JSON.parse(JSON.stringify(slotProps.node));
+                pointCopy.label = slotProps.node.label;
+                this.readDevices[foundDeviceIndex].children[0].children.push(pointCopy);
               }
             }
 
@@ -321,6 +331,10 @@
             }
 
             let point = this.pointList[key][slotProps.node.pointName];
+            // Preserve any existing display name when adding to pointsToRead
+            if (slotProps.node.label !== slotProps.node.pointName) {
+              point.displayName = slotProps.node.label;
+            }
             this.pointsToRead[key][point.objectName] = point;
 
             //force a deploy state
@@ -566,6 +580,27 @@
               pointMenu.classList.remove("pointAddedToRead");
             }
           },
+          // NEW: Handle right-click on MSTP network folders
+          onMstpFolderRightClick(slotProps, event) {
+            let app = this;
+            app.rightClickedMstpFolder = slotProps;
+            event.preventDefault();
+            event.stopPropagation();
+
+            // Hide other context menus first
+            const menu = document.querySelector(".context-menu");
+            const pointMenu = document.querySelector(".point-context-menu");
+            if (menu) menu.style.display = "none";
+            if (pointMenu) pointMenu.style.display = "none";
+
+            const mstpFolderMenu = document.querySelector(".mstp-folder-context-menu");
+
+            if (mstpFolderMenu) {
+              mstpFolderMenu.style.setProperty("--mouse-x", event.clientX + "px");
+              mstpFolderMenu.style.setProperty("--mouse-y", event.clientY + "px");
+              mstpFolderMenu.style.display = "block";
+            }
+          },
           handleContextMenuClick(type) {
             let app = this;
             switch (type) {
@@ -589,6 +624,17 @@
                 break;
             }
           },
+          // NEW: Handle context menu clicks for MSTP folders
+          handleMstpFolderContextMenuClick(type) {
+            let app = this;
+            switch (type) {
+              case "updateAllDevices":
+                app.updateAllMstpDevices(app.rightClickedMstpFolder);
+                break;
+              default:
+                break;
+            }
+          },
           handlePointContextMenuClick(type) {
             let app = this;
             switch (type) {
@@ -603,18 +649,52 @@
                 break;
             }
           },
+          // NEW: Update all devices within an MSTP network folder
+          updateAllMstpDevices(slotProps) {
+            let app = this;
+
+            if (!slotProps || !slotProps.node || !slotProps.node.children) {
+              return;
+            }
+
+            const mstpDevices = slotProps.node.children;
+            let updatedCount = 0;
+
+            // Iterate through all MSTP devices in the folder
+            mstpDevices.forEach(function (mstpDevice) {
+              // Find the device in the device list
+              let device = app.getDeviceFromDeviceList(mstpDevice.ipAddr, mstpDevice.deviceId);
+              if (device) {
+                app.nodeService.updatePointsForDevice(device).then(function (result) {
+                  updatedCount++;
+                }).catch(function (error) {
+                  // Handle error silently
+                });
+              }
+            });
+
+            // Show user feedback
+            if (mstpDevices.length > 0) {
+              app.$toast?.add({
+                severity: 'info',
+                summary: 'Update Started',
+                detail: `Updating points for ${mstpDevices.length} devices in ${slotProps.node.label}`,
+                life: 3000
+              });
+            }
+          },
           purgeDevice(slotProps) {
             let app = this;
             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.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) {
@@ -625,7 +705,7 @@
             });
             const deviceKey = `${app.getDeviceAddress(device.address)}-${device.deviceId}`;
             if (device) {
-              app.nodeService.updatePoint(deviceKey, pointKey).then(function (result) {});
+              app.nodeService.updatePoint(deviceKey, pointKey).then(function (result) { });
             }
           },
           setDeviceName() {
@@ -660,13 +740,95 @@
 
               app.nodeService.setPointDisplayName(deviceKey, pointName, pointDisplayName).then(function (result) {
                 if (result) {
-                  slotProps.node.label = pointDisplayName;
+                  // Update the display name across all UI representations
+                  app.syncPointDisplayNameAcrossUI(deviceKey, pointName, pointDisplayName);
+                  app.updatePointsToReadDisplayName(deviceKey, pointName, pointDisplayName);
                 }
               });
             }
 
             app.showPointNameDialog = false;
           },
+          // NEW: Centralized method to sync display names across all UI trees
+          syncPointDisplayNameAcrossUI(deviceKey, pointName, newDisplayName) {
+            let app = this;
+
+            // Update in main devices tree
+            app.updatePointDisplayNameInDevicesTree(deviceKey, pointName, newDisplayName);
+
+            // Update in read devices tree
+            app.updatePointDisplayNameInReadDevicesTree(deviceKey, pointName, newDisplayName);
+
+            // Force UI update
+            app.$forceUpdate();
+          },
+          // NEW: Update display name in main devices tree
+          updatePointDisplayNameInDevicesTree(deviceKey, pointName, newDisplayName) {
+            let app = this;
+            let [ipAddress, deviceId] = deviceKey.split('-');
+
+            // Find the device in main tree
+            let deviceIndex = app.devices ? app.devices.findIndex(device =>
+              device.ipAddr === ipAddress && device.deviceId.toString() === deviceId) : -1;
+
+            if (deviceIndex !== -1) {
+              // Update direct device points
+              let pointIndex = app.devices[deviceIndex].children[0].children.findIndex(point =>
+                point.pointName === pointName);
+              if (pointIndex !== -1) {
+                app.devices[deviceIndex].children[0].children[pointIndex].label = newDisplayName;
+              }
+
+              // Update MSTP device points if applicable
+              app.devices[deviceIndex].children.forEach(child => {
+                if (child.label && child.label.includes("MSTP") && child.children) {
+                  child.children.forEach(mstpDevice => {
+                    if (mstpDevice.deviceId.toString() === deviceId) {
+                      let mstpPointIndex = mstpDevice.children[0].children.findIndex(point =>
+                        point.pointName === pointName);
+                      if (mstpPointIndex !== -1) {
+                        mstpDevice.children[0].children[mstpPointIndex].label = newDisplayName;
+                      }
+                    }
+                  });
+                }
+              });
+            }
+          },
+          // NEW: Update display name in read devices tree
+          updatePointDisplayNameInReadDevicesTree(deviceKey, pointName, newDisplayName) {
+            let app = this;
+            let [ipAddress, deviceId] = deviceKey.split('-');
+
+            if (!app.readDevices) return;
+
+            // Find the device in read devices tree
+            let readDeviceIndex = app.readDevices.findIndex(device =>
+              device.deviceId.toString() === deviceId);
+
+            if (readDeviceIndex !== -1) {
+              let pointIndex = app.readDevices[readDeviceIndex].children[0].children.findIndex(point =>
+                point.pointName === pointName);
+              if (pointIndex !== -1) {
+                app.readDevices[readDeviceIndex].children[0].children[pointIndex].label = newDisplayName;
+              }
+            }
+          },
+          // NEW: Update display name in pointsToRead data structure
+          updatePointsToReadDisplayName(deviceKey, pointName, newDisplayName) {
+            let app = this;
+
+            if (app.pointsToRead && app.pointsToRead[deviceKey]) {
+              // Find the point by objectName (since pointsToRead uses objectName as key)
+              for (let objectName in app.pointsToRead[deviceKey]) {
+                let point = app.pointsToRead[deviceKey][objectName];
+                if (point && point.objectName === pointName) {
+                  point.displayName = newDisplayName;
+                  break;
+                }
+              }
+            }
+          },
           getDeviceFromDeviceList(ip, id) {
             let app = this;
             let device = app.deviceList.find((ele) => {
@@ -896,7 +1058,30 @@
             app.$forceUpdate();
           },
           refreshReadListTree() {
-            this.addToReadDevices(this.pointsToRead);
+            // Enhanced refresh that maintains display names
+            let app = this;
+
+            // First apply any saved display names to the current pointsToRead
+            app.applyStoredDisplayNames();
+
+            // Then rebuild the read list tree
+            app.addToReadDevices(app.pointsToRead);
+          },
+          // NEW: Apply stored display names from backend to current data
+          applyStoredDisplayNames() {
+            let app = this;
+
+            if (!app.pointsToRead) return;
+
+            // Send current pointsToRead to backend to apply any stored display names
+            let msg = { applyDisplayNames: true };
+            // This will be handled by the backend node to apply stored display names
+            app.nodeService.applyDisplayNames(app.pointsToRead).then(function (result) {
+              if (result) {
+                // Refresh the main tree with updated display names
+                app.getData();
+              }
+            });
           },
           calculateMstpCount(slotProps) {
             let count = 0;
@@ -912,6 +1097,7 @@
             let count = 0;
             return count;
           },
+
         },
         components: {
           "p-tree": primevue.tree,
@@ -970,6 +1156,13 @@
         pointMenu.style.display = "none";
       });
 
+      var mstpFolderMenu = document.querySelector(".mstp-folder-context-menu");
+      window.addEventListener("click", (event) => {
+        if (menu) menu.style.display = "none";
+        if (pointMenu) pointMenu.style.display = "none";
+        if (mstpFolderMenu) mstpFolderMenu.style.display = "none";
+      });
+
       function handleCheckboxClick() {
         if (this.id == "node-input-object_property_simplePayload") {
           document.getElementById("node-input-object_property_fullObject").checked = false;
@@ -1113,6 +1306,18 @@
     </ul>
     <!-- End Point Context Menu -->
 
+    <!-- Start MSTP Folder 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 mstp-folder-context-menu">
+      <li class="context-menu-item" @click="handleMstpFolderContextMenuClick('updateAllDevices')">
+        <a class="red-ui-menu-label">
+          <i class="pi pi-refresh context-menu-icon"></i>
+          <span class="context-menu-item-text">Update All Devices</span>
+        </a>
+      </li>
+    </ul>
+    <!-- End MSTP Folder Context Menu -->
+
     <!--
                 *
                 *
@@ -1194,6 +1399,7 @@
             filterMode="lenient"
             filterPlaceholder="No results found."
             v-if="hasData()">
+
             <template #device="slotProps">
               <div @contextmenu="onDeviceRightClick(slotProps, $event)" class="p-treenode-label">
                 <div v-if="isDeviceActive(slotProps)" class="deviceLabelParent">
@@ -1233,6 +1439,20 @@
               </div>
             </template>
 
+            
+            <template #mstpfolder="slotProps">
+              <div @contextmenu="onMstpFolderRightClick(slotProps, $event)" class="p-treenode-label">
+                <div class="deviceLabelParent">
+                  <b class="mstpLabel">
+                    <span>{{slotProps.node.label}}</span>
+                    <span class="mstpDeviceCount" >
+                      &nbsp; {{slotProps.node.children ? slotProps.node.children.length : 0}} &nbsp;
+                    </span>
+                  </b>
+                </div>
+              </div>
+            </template>
+
             <template #point="slotProps" v-model:class="pointContent">
               <div @contextmenu="onPointRightClick(slotProps, $event)">
                 <b class="pointLabel">{{slotProps.node.label}}</b>
@@ -1253,6 +1473,7 @@
                 </button>
               </div>
             </template>
+
           </p-tree>
           <div v-else style="text-align: center; padding-top: 20px;">
             <a>Building Tree...</a>
@@ -1492,4 +1713,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

@@ -99,7 +99,19 @@ module.exports = function (RED) {
           useDeviceName = node.useDeviceName;
         }
 
-        let readConfig = new ReadCommandConfig(node.pointsToRead, node.object_props, node.roundDecimal);
+        // Ensure pointsToRead has the latest display names before processing
+        let pointsToReadWithDisplayNames = JSON.parse(JSON.stringify(node.pointsToRead));
+
+        // Apply any stored display names from the backend data model
+        for (let deviceKey in pointsToReadWithDisplayNames) {
+          for (let pointKey in pointsToReadWithDisplayNames[deviceKey]) {
+            let point = pointsToReadWithDisplayNames[deviceKey][pointKey];
+            // The display name should already be preserved in the point object
+            // from the setPointDisplayName operations and addPointClicked enhancements
+          }
+        }
+
+        let readConfig = new ReadCommandConfig(pointsToReadWithDisplayNames, node.object_props, node.roundDecimal);
 
         let output = {
           type: "Read",

package/inspector.html

@@ -186,7 +186,11 @@
             </div>
           </template>
           <p-column v-for="col in visibleColumns" :key="col.field" :field="col.field" :header="col.header" sortable
-            filter></p-column>
+            filter>
+            <template #body="slotProps" v-if="col.field === 'objectType'">
+              {{ getObjectTypeString(slotProps.data.objectType) }}
+            </template>
+          </p-column>
           <template #paginatorstart>
 
           </template>
@@ -331,6 +335,36 @@
         },
       },
       methods: {
+        getObjectTypeString(objectType) {
+          switch (objectType) {
+            case 0:
+              return "Analog Input";
+            case 1:
+              return "Analog Output";
+            case 2:
+              return "Analog Value";
+            case 3:
+              return "Binary Input";
+            case 4:
+              return "Binary Output";
+            case 5:
+              return "Binary Value";
+            case 8:
+              return "Device";
+            case 10:
+              return "File";
+            case 13:
+              return "Multistate Input";
+            case 14:
+              return "Multistate Output";
+            case 19:
+              return "Multistate Value";
+            case 40:
+              return "Character String";
+            default:
+              return "";
+          }
+        },
         statusItemClicked(e) {
           // Get the filter category from the clicked item's text content
           const clickedItem = e.currentTarget;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitpoolos/edge-bacnet",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "A bacnet gateway for node-red",
   "dependencies": {
     "@plus4nodered/ts-node-bacnet": "^1.0.0-beta.2",