@bitpoolos/edge-bacnet 1.6.2 → 1.6.4

package/bacnet_read.html

@@ -62,6 +62,7 @@
             progressBarValue: ref(),
             rightClickedDevice: ref(),
             rightClickedPoint: ref(),
+            rightClickedMstpFolder: ref(),
             showDeviceNameDialog: ref(false),
             showPointNameDialog: ref(false),
             deviceDisplayNameValue: ref(),
@@ -130,10 +131,7 @@
           getData(initial) {
             let app = this;
             this.nodeService.getNetworkData().then(function (result) {
-              //remove after below fixed
               app.devices = result.renderList;
-              //end remove
-
               app.deviceList = result.deviceList;
               app.pointList = result.pointList;
               app.pollFrequency = parseInt(result.pollFrequency);
@@ -288,7 +286,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 +311,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 +328,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 +577,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 +621,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,6 +646,43 @@
                 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);
@@ -660,13 +740,94 @@
 
               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 +1057,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;
@@ -970,6 +1154,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 +1304,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 -->
+
     <!--
                 *
                 *
@@ -1233,6 +1436,19 @@
               </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>

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/common.js

@@ -4,6 +4,7 @@
 
 const { randomUUID } = require("crypto");
 const os = require("os");
+const path = require("path");
 const baEnum = require("./resources/node-bacstack-ts/dist/index.js").enum;
 const fs = require("fs");
 const fs2 = require("fs").promises;
@@ -189,27 +190,16 @@ const roundDecimalPlaces = function (value, decimals) {
   return value;
 };
 
-// STORE CONFIG FUNCTION ==========================================================
-//
-// ================================================================================
-
-/*
-
-async function Store_Config(data) {
-  try {
-    await fs.writeFile("edge-bacnet-datastore.cfg", data, { encoding: "utf8", flag: "w" }, (err) => {
-      if (err) {
-        console.log("Store_Config writeFile error: ", err);
-      }
-    });
-  } catch (e) {
-    //do nothing
+const getStoragePath = (fileName) => {
+  const storagePath = process.env.BACNET_STORAGE_PATH;
+  if (storagePath) {
+    if (!fs.existsSync(storagePath)) {
+      fs.mkdirSync(storagePath, { recursive: true });
+    }
+    return path.join(storagePath, fileName);
   }
-}
-
-*/
-
-// refactor:
+  return fileName;
+};
 
 let storeQueue = [];
 let isStoreProcessing = false;
@@ -235,9 +225,9 @@ async function queueConfigStore(data) {
 }
 
 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";
+  const mainFile = getStoragePath("edge-bacnet-datastore.cfg");
+  const tempFile = getStoragePath("edge-bacnet-datastore.cfg.tmp");
+  const backupFile = getStoragePath("edge-bacnet-datastore.cfg.bak");
 
   try {
     // First validate the JSON to ensure it's valid before writing
@@ -295,54 +285,10 @@ async function Store_Config(data) {
   }
 }
 
-// READ CONFIG SYNC FUNCTION ======================================================
-//
-// ================================================================================
-
-function Read_Config_Sync() {
-  const mainFile = "edge-bacnet-datastore.cfg";
-  const backupFile = "edge-bacnet-datastore.cfg.bak";
-  const defaultData = "{}";
-
-  try {
-    // 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 mainFile = getStoragePath("edge-bacnet-datastore.cfg");
+  const backupFile = getStoragePath("edge-bacnet-datastore.cfg.bak");
   const defaultData = "{}";
 
   try {
@@ -366,15 +312,11 @@ async function Read_Config_Async() {
         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;
       }
     }
@@ -382,8 +324,6 @@ async function Read_Config_Async() {
     console.error("Error reading config:", error);
     await Store_Config(defaultData);
 
-    console.log("log4");
-
     return defaultData;
   }
 }
@@ -393,7 +333,7 @@ async function Read_Config_Async() {
 // ================================================================================
 async function Store_Config_Server(data) {
   try {
-    await fs.writeFile("edge-bacnet-server-datastore.cfg", data, (err) => {
+    await fs.writeFile(getStoragePath("edge-bacnet-server-datastore.cfg"), data, (err) => {
       if (err) {
         //console.log("Store_Config_Server writeFile error: ", err);
       }
@@ -407,7 +347,7 @@ async function Store_Config_Server(data) {
 function Read_Config_Sync_Server() {
   var data = "{}";
   try {
-    data = fs.readFileSync("edge-bacnet-server-datastore.cfg", { encoding: "utf8", flag: "r" });
+    data = fs.readFileSync(getStoragePath("edge-bacnet-server-datastore.cfg"), { encoding: "utf8", flag: "r" });
   } catch (err) {
     if (err.errno == -4058) {
       data = "{}";
@@ -485,7 +425,6 @@ module.exports = {
   roundDecimalPlaces,
   queueConfigStore,
   Store_Config,
-  Read_Config_Sync,
   Read_Config_Async,
   Store_Config_Server,
   Read_Config_Sync_Server,

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.4",
   "description": "A bacnet gateway for node-red",
   "dependencies": {
     "@plus4nodered/ts-node-bacnet": "^1.0.0-beta.2",
@@ -54,4 +54,4 @@
     "type": "github",
     "url": "git+https://github.com/bitpool/edge-bacnet.git"
   }
-}
+}

package/resources/style.css

@@ -339,7 +339,9 @@
     cursor: not-allowed;
   }
 }
-
+.mstpLabel {
+  font-weight: 400;
+}
 .point-context-menu {
   --mouse-x: 0;
   --mouse-y: 0;
@@ -352,6 +354,18 @@
   transform: translateX(min(var(--mouse-x), calc(100vw - 100%))) translateY(min(var(--mouse-y), calc(100vh - 100%)));
   z-index: 10;
 }
+.mstp-folder-context-menu {
+  --mouse-x: 0;
+  --mouse-y: 0;
+  display: none;
+  position: fixed;
+  margin: 0;
+  left: 0;
+  top: 0;
+  /* The following line is responsible for all the magic */
+  transform: translateX(min(var(--mouse-x), calc(100vw - 100%))) translateY(min(var(--mouse-y), calc(100vh - 100%)));
+  z-index: 10;
+}
 .context-menu {
   --mouse-x: 0;
   --mouse-y: 0;
@@ -765,4 +779,17 @@
 .p-confirm-dialog-accept > .p-button-label,
 .bacnetServerRebuildSchedule_clearButton > .p-button-label {
   color: white;
+}
+
+.deviceFolderLabel {
+  display: flex;
+  align-items: center;
+  color: #333;
+  font-weight: 600;
+}
+
+.deviceFolderLabel:hover {
+  background-color: #f8f9fa;
+  border-radius: 4px;
+  padding: 2px 4px;
 }