homebridge-unifi-protect 6.8.1 → 6.9.1

package/homebridge-ui/public/index.html

@@ -178,6 +178,10 @@
       // Retrieve the current plugin configuration.
       let currentConfig = await homebridge.getPluginConfig();
 
+      // Keep a list of all the feature options and option groups.
+      let featureOptionList = {};
+      let featureOptionGroups = {};
+
       // Show an navigation bar at the top of the plugin configuration UI.
       const showIntro = () => {
 
@@ -321,7 +325,6 @@
           controllersTable.appendChild(trDevice);
 
           controllerList.push(label);
-
         }
 
         // All done. Let the user interact with us.
@@ -454,32 +457,32 @@
         };
 
         // Initialize our feature option configuration.
-        updateConfigOptions(currentConfig[0].options ?? [])
+        updateConfigOptions(currentConfig[0].options ?? []);
 
         // Is this feature option set explicitly?
         const isOptionSet = (featureOption, deviceMac) => {
 
-          const optionRegex = new RegExp("^(Enable|Disable)\." + featureOption + (!deviceMac ? "" : "\." + deviceMac) + "$", "gi");
-          return optionsList.filter(x => x.match(optionRegex)).length ? true : false;
+          const optionRegex = new RegExp("^(?:Enable|Disable)\\." + featureOption + (!deviceMac ? "" : "\\." + deviceMac) + "$", "gi");
+          return optionsList.filter(x => optionRegex.test(x)).length ? true : false;
         };
 
         // Is a feature option globally enabled?
-        const isGlobalOptionEnabled = (featureOption, defaultValue) => {
+        const isGlobalOptionEnabled = (featureOption, defaultState) => {
 
           featureOption = featureOption.toUpperCase();
 
           // Test device-specific options.
           return optionsList.some(x => x === ("ENABLE." + featureOption)) ? true :
-            (optionsList.some(x => x === ("DISABLE." + featureOption)) ? false : defaultValue
+            (optionsList.some(x => x === ("DISABLE." + featureOption)) ? false : defaultState
             );
         };
 
-        // Is a feature option enabled at the device or global level. It does not traverse the scoping hierarchy.
-        const isDeviceOptionEnabled = (featureOption, mac, defaultValue) => {
+        // Is a feature option enabled at the device or global level. This function does not traverse the scoping hierarchy.
+        const isDeviceOptionEnabled = (featureOption, mac, defaultState) => {
 
           if(!mac) {
 
-            return isGlobalOptionEnabled(featureOption, defaultValue);
+            return isGlobalOptionEnabled(featureOption, defaultState);
           }
 
           featureOption = featureOption.toUpperCase();
@@ -487,60 +490,113 @@
 
           // Test device-specific options.
           return optionsList.some(x => x === ("ENABLE." + featureOption + "." + mac)) ? true :
-            (optionsList.some(x => x === ("DISABLE." + featureOption + "." + mac)) ? false : defaultValue
+            (optionsList.some(x => x === ("DISABLE." + featureOption + "." + mac)) ? false : defaultState
             );
         };
 
+        // Is a value-centric feature option enabled at the device or global level. This function does not traverse the scoping hierarchy.
+        const isOptionValueSet = (featureOption, deviceMac) => {
+
+          const optionRegex = new RegExp("^Enable\\." + featureOption + (!deviceMac ? "" : "\\." + deviceMac) + "\\.([^\\.]+)$", "gi");
+
+          return optionsList.filter(x => optionRegex.test(x)).length ? true : false;
+        };
+
+        // Get the value of a value-centric feature option.
+        const getOptionValue = (featureOption, deviceMac) => {
+
+          const optionRegex = new RegExp("^Enable\\." + featureOption + (!deviceMac ? "" : "\\." + deviceMac) + "\\.([^\\.]+)$", "gi");
+
+          // Get the option value, if we have one.
+          for(const option of optionsList) {
+
+            const regexMatch = optionRegex.exec(option);
+
+            if(regexMatch) {
+
+              return regexMatch[1];
+            }
+          }
+
+          return undefined;
+        };
+
         // Is a feature option enabled at the device or global level. It does traverse the scoping hierarchy.
-        const isOptionEnabled = (featureOption, deviceMac, defaultValue) => {
+        const isOptionEnabled = (featureOption, deviceMac) => {
+
+          const defaultState = featureOptionList[featureOption]?.default ?? true;
 
           if(deviceMac) {
 
             // Device level check.
-            if(isDeviceOptionEnabled(featureOption, deviceMac, defaultValue) !== defaultValue) {
+            if(isDeviceOptionEnabled(featureOption, deviceMac, defaultState) !== defaultState) {
 
-              return !defaultValue;
+              return !defaultState;
             }
 
             // Controller level check.
-            if(isDeviceOptionEnabled(featureOption, nvr.mac, defaultValue) !== defaultValue) {
+            if(isDeviceOptionEnabled(featureOption, nvr.mac, defaultState) !== defaultState) {
 
-              return !defaultValue;
+              return !defaultState;
             }
           }
 
           // Global check.
-          if(isGlobalOptionEnabled(featureOption, defaultValue) !== defaultValue) {
+          if(isGlobalOptionEnabled(featureOption, defaultState) !== defaultState) {
 
-            return !defaultValue;
+            return !defaultState;
           }
 
           // Return the default.
-          return defaultValue;
+          return defaultState;
         };
 
         // Return the scope level of a feature option.
-        const optionScope = (featureOption, deviceMac, defaultValue) => {
+        const optionScope = (featureOption, deviceMac, defaultState, isOptionValue = false) => {
 
           // Scope priority is always: device, NVR, global.
 
+          // If we have a value-centric feature option, our lookups are a bit different.
+          if(isOptionValue) {
+
+            if(deviceMac) {
+
+              if(isOptionValueSet(featureOption, deviceMac)) {
+
+                return "device";
+              }
+
+              if(isOptionValueSet(featureOption, nvr.mac)) {
+
+                return "nvr";
+              }
+            }
+
+            if(isOptionValueSet(featureOption)) {
+
+              return "global";
+            }
+
+            return "none";
+          }
+
           if(deviceMac) {
 
             // Let's see if we've set it at the device-level.
-            if((isDeviceOptionEnabled(featureOption, deviceMac, defaultValue) !== defaultValue) || isOptionSet(featureOption, deviceMac)) {
+            if((isDeviceOptionEnabled(featureOption, deviceMac, defaultState) !== defaultState) || isOptionSet(featureOption, deviceMac)) {
 
               return "device";
             }
 
             // Now let's test the controller level.
-            if((isDeviceOptionEnabled(featureOption, nvr.mac, defaultValue) !== defaultValue) || isOptionSet(featureOption, nvr.mac)) {
+            if((isDeviceOptionEnabled(featureOption, nvr.mac, defaultState) !== defaultState) || isOptionSet(featureOption, nvr.mac)) {
 
               return "nvr";
             }
           }
 
           // Finally, let's test the global level.
-          if((isGlobalOptionEnabled(featureOption, defaultValue) !== defaultValue) || isOptionSet(featureOption)) {
+          if((isGlobalOptionEnabled(featureOption, defaultState) !== defaultState) || isOptionSet(featureOption)) {
 
             return "global";
           }
@@ -550,9 +606,9 @@
         };
 
         // Return the color hinting for a given option's scope.
-        const optionScopeColor = (featureOption, deviceMac, defaultValue) => {
+        const optionScopeColor = (featureOption, deviceMac, defaultState, isOptionValue) => {
 
-          switch(optionScope(featureOption, deviceMac, defaultValue)) {
+          switch(optionScope(featureOption, deviceMac, defaultState, isOptionValue)) {
 
             case "device":
 
@@ -623,6 +679,36 @@
           let newConfigTableHtml = "";
           configTable.innerHTML = "";
 
+          // Initialize the full list of options.
+          featureOptionList = {};
+          featureOptionGroups = {};
+
+          for(const category of ufpFeatures.categories) {
+
+            // Now enumerate all the feature options for a given device and add then to the full list.
+            for(const option of optionsDevice[category.name]) {
+
+              const featureOption = category.name + (option.name.length ? ("." + option.name): "");
+
+              // Add it to our full list.
+              featureOptionList[featureOption] = option;
+
+              // Cross reference the feature option group it belongs to, if any.
+              if(option.group !== undefined) {
+
+                const expandedGroup = category.name + (option.group.length ? ("." + option.group): "");
+
+                // Initialize the group entry if needed.
+                if(!featureOptionGroups[expandedGroup]) {
+
+                  featureOptionGroups[expandedGroup] = [];
+                }
+
+                featureOptionGroups[expandedGroup].push(featureOption);
+              }
+            }
+          }
+
           for(const category of ufpFeatures.categories) {
 
             // Only show feature option categories that are valid for this context.
@@ -641,7 +727,7 @@
             optionTable.classList.add("table", "table-borderless", "table-sm", "table-hover");
             th.classList.add("p-0");
             th.style.fontWeight = "bold";
-            th.colSpan = 2;
+            th.colSpan = 3;
             tbody.classList.add("table-bordered");
 
             // Add the feature option category description.
@@ -667,9 +753,13 @@
                 continue;
               }
 
+              // Expand the full feature option.
+              const featureOption = category.name + (option.name.length ? ("." + option.name): "");
+
               // Create the next table row.
               const trX = document.createElement("tr");
               trX.classList.add("align-top");
+              trX.id = "row-" + featureOption;
 
               // Create a checkbox for the option.
               const tdCheckbox = document.createElement("td");
@@ -677,14 +767,17 @@
               // Create the actual checkbox for the option.
               const checkbox = document.createElement("input");
 
-              const featureOption = category.name + (option.name.length ? ("." + option.name): "");
               checkbox.type = "checkbox";
               checkbox.readOnly = false;
               checkbox.id = featureOption;
               checkbox.name = featureOption;
               checkbox.value = featureOption + (!ufpDevice ? "" : ("." + ufpDevice.mac));
 
-              switch(optionScope(featureOption, ufpDevice?.mac, option.default)) {
+              let initialValue = undefined;
+              let initialScope;
+
+              // Determine our initial option scope to show the user what's been set.
+              switch(initialScope = optionScope(featureOption, ufpDevice?.mac, option.default, ("defaultValue" in option))) {
 
                 case "global":
                 case "nvr":
@@ -692,7 +785,14 @@
                   // If we're looking at the global scope, show the option value. Otherwise, we show that we're inheriting a value from the scope above.
                   if(!ufpDevice) {
 
-                    checkbox.checked = isGlobalOptionEnabled(featureOption, option.default);
+                    if("defaultValue" in option) {
+
+                      checkbox.checked = isOptionValueSet(featureOption);
+                      initialValue = getOptionValue(checkbox.id);
+                    } else {
+
+                      checkbox.checked = isGlobalOptionEnabled(featureOption, option.default);
+                    }
 
                     if(checkbox.checked) {
 
@@ -701,6 +801,11 @@
 
                   } else {
 
+                    if("defaultValue" in option) {
+
+                      initialValue = getOptionValue(checkbox.id, (initialScope === "nvr") ? nvr.mac : undefined);
+                    }
+
                     checkbox.readOnly = checkbox.indeterminate = true;
                   }
 
@@ -709,7 +814,16 @@
                 case "device":
                 case "none":
                 default:
-                  checkbox.checked = isDeviceOptionEnabled(featureOption, ufpDevice?.mac, option.default);
+
+                  if("defaultValue" in option) {
+
+                    checkbox.checked = isOptionValueSet(featureOption, ufpDevice?.mac);
+                    initialValue = getOptionValue(checkbox.id, ufpDevice?.mac);
+                  } else {
+
+                    checkbox.checked = isDeviceOptionEnabled(featureOption, ufpDevice?.mac, option.default);
+                  }
+
                   break;
               }
 
@@ -724,6 +838,51 @@
 
               const tdLabel = document.createElement("td");
               tdLabel.classList.add("w-100");
+              tdLabel.colSpan = 2;
+
+              let inputValue = null;
+
+              // Add an input field if we have a value-centric feature option.
+              if(("defaultValue" in option)) {
+
+                const tdInput = document.createElement("td");
+                tdInput.classList.add("mr-2");
+                tdInput.style.width = "10%";
+
+                inputValue = document.createElement("input");
+                inputValue.type = "text";
+                inputValue.value = initialValue ?? option.defaultValue;
+                inputValue.size = 5;
+                inputValue.readOnly = !checkbox.checked;
+
+                // Add or remove the setting from our configuration when we've changed our state.
+                inputValue.addEventListener("change", async () => {
+
+                  // Find the option in our list and delete it if it exists.
+                  const optionRegex = new RegExp("^(?:Enable|Disable)\\." + checkbox.id + (!ufpDevice ? "" : ("\\." + ufpDevice.mac)) + "\\.[^\\.]+$", "gi");
+                  const newOptions = configOptions.filter(x => !optionRegex.test(x));
+
+                  if(checkbox.checked) {
+
+                    newOptions.push("Enable." + checkbox.value + "." + inputValue.value);
+                  } else if(checkbox.indeterminate) {
+
+                    // If we're in an indeterminate state, we need to traverse the tree to get the upstream value we're inheriting.
+                    inputValue.value = (ufpDevice?.mac !== nvr.mac) ? (getOptionValue(checkbox.id, nvr.mac) ?? getOptionValue(checkbox.id)) : (getOptionValue(checkbox.id) ?? option.defaultValue);
+                  } else {
+
+                    inputValue.value = option.defaultValue;
+                  }
+
+                  // Update our configuration in Homebridge.
+                  currentConfig[0].options = newOptions;
+                  updateConfigOptions(newOptions);
+                  await homebridge.updatePluginConfig(currentConfig);
+                });
+
+                tdInput.appendChild(inputValue);
+                trX.appendChild(tdInput);
+              }
 
               // Create a label for the checkbox with our option description.
               const labelDescription = document.createElement("label");
@@ -732,7 +891,7 @@
               labelDescription.classList.add("user-select-none", "my-0", "py-0");
 
               // Highlight options for the user that are different than our defaults.
-              const scopeColor = optionScopeColor(featureOption, ufpDevice?.mac, option.default);
+              const scopeColor = optionScopeColor(featureOption, ufpDevice?.mac, option.default, ("defaultValue" in option));
 
               if(scopeColor) {
 
@@ -743,14 +902,14 @@
               checkbox.addEventListener("change", async () => {
 
                 // Find the option in our list and delete it if it exists.
-                const optionRegex = new RegExp("^(Enable|Disable)\." + checkbox.id + (!ufpDevice ? "" : ("\." + ufpDevice.mac)) + "$", "gi");
-                const newOptions = configOptions.filter(x => !x.match(optionRegex));
+                const optionRegex = new RegExp("^(?:Enable|Disable)\\." + checkbox.id + (!ufpDevice ? "" : ("\\." + ufpDevice.mac)) + "$", "gi");
+                const newOptions = configOptions.filter(x => !optionRegex.test(x));
 
                 // Figure out if we've got the option set upstream.
                 let upstreamOption = false;
 
                 // We explicitly want to check for the scope of the feature option above where we are now, so we can appropriately determine what we should show.
-                switch(optionScope(checkbox.id, (ufpDevice && (ufpDevice.mac !== nvr.mac)) ? nvr.mac : null, option.default)) {
+                switch(optionScope(checkbox.id, (ufpDevice && (ufpDevice.mac !== nvr.mac)) ? nvr.mac : null, option.default, ("defaultValue" in option))) {
 
                   case "device":
                   case "nvr":
@@ -776,7 +935,8 @@
                     break;
                 }
 
-                if(checkbox.readOnly) {
+                // For value-centric feature options, if there's an upstream value assigned above us, we don't allow for an unchecked state as it makes no sense in that context.
+                if(checkbox.readOnly && (!("defaultValue" in option) || (("defaultValue" in option) && inputValue && !upstreamOption))) {
 
                   // We're truly unchecked. We need this because a checkbox can be in both an unchecked and indeterminate simultaneously,
                   // so we use the readOnly property to let us know that we've just cycled from an indeterminate state.
@@ -791,10 +951,19 @@
                     checkbox.readOnly = checkbox.indeterminate = true;
                   }
 
+                  if(("defaultValue" in option) && inputValue) {
+
+                    inputValue.readOnly = true;
+                  }
                 } else if(checkbox.checked) {
 
                   // We've explicitly checked this option.
                   checkbox.readOnly = checkbox.indeterminate = false;
+
+                  if(("defaultValue" in option) && inputValue) {
+
+                    inputValue.readOnly = false;
+                  }
                 }
 
                 // The setting is different from the default, highlight it for the user, accounting for upstream scope, and add it to our configuration.
@@ -808,21 +977,43 @@
                   labelDescription.classList.remove("text-info");
                 }
 
-                // Update our configuration in Homebridge.
-                currentConfig[0].options = newOptions;
-                updateConfigOptions(newOptions);
-                await homebridge.updatePluginConfig(currentConfig);
+                // Update our Homebridge configuration.
+                if(("defaultValue" in option) && inputValue) {
+
+                  // Inform our value-centric feature option to update Homebridge.
+                  const changeEvent = new Event("change");
+
+                  inputValue.dispatchEvent(changeEvent);
+                } else {
+
+                  // Update our configuration in Homebridge.
+                  currentConfig[0].options = newOptions;
+                  updateConfigOptions(newOptions);
+                  await homebridge.updatePluginConfig(currentConfig);
+                }
 
                 // If we've reset to defaults, make sure our color coding for scope is reflected.
                 if((checkbox.checked === option.default) || checkbox.indeterminate) {
 
-                  const scopeColor = optionScopeColor(featureOption, ufpDevice?.mac, option.default);
+                  const scopeColor = optionScopeColor(featureOption, ufpDevice?.mac, option.default, ("defaultValue" in option));
 
                   if(scopeColor) {
 
                     labelDescription.classList.add(scopeColor);
                   }
                 }
+
+                // Adjust visibility of other feature options that depend on us.
+                if(featureOptionGroups[checkbox.id]) {
+
+                  const entryVisibility = isOptionEnabled(featureOption, ufpDevice?.mac) ? "" : "none";
+
+                  // Lookup each feature option setting and set the visibility accordingly.
+                  for(const entry of featureOptionGroups[checkbox.id]) {
+
+                    document.getElementById("row-" + entry).style.display = entryVisibility;
+                  }
+                }
               });
 
               // Add the actual description for the option after the checkbox.
@@ -837,6 +1028,12 @@
               // Add the label table cell to the table row.
               trX.appendChild(tdLabel);
 
+              // Adjust the visibility of the feature option, if it's logically grouped.
+              if((option.group !== undefined) && !isOptionEnabled(category.name + (option.group.length ? ("." + option.group): ""), ufpDevice?.mac)) {
+
+                trX.style.display = "none";
+              }
+
               // Add the table row to the table body.
               tbody.appendChild(trX);
             }

package/homebridge-ui/server.js

@@ -11,7 +11,7 @@
 /* eslint-disable new-cap */
 "use strict";
 
-import { featureOptionCategories, featureOptions, optionEnabled } from "../dist/protect-options.js";
+import { featureOptionCategories, featureOptions, isOptionEnabled } from "../dist/protect-options.js";
 import { HomebridgePluginUiServer } from "@homebridge/plugin-ui-utils";
 import { ProtectApi } from "unifi-protect";
 import * as fs from "node:fs";
@@ -113,7 +113,7 @@ class PluginUiServer extends HomebridgePluginUiServer {
 
           for(const options of featureOptions[category.name]) {
 
-            options.value = optionEnabled(request.configOptions, request.nvrUfp, request.deviceUfp, category.name + "." + options.name, options.default);
+            options.value = isOptionEnabled(request.configOptions, request.nvrUfp, request.deviceUfp, category.name + "." + options.name, options.default);
             optionSet[category.name].push(options);
           }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-unifi-protect",
-  "version": "6.8.1",
+  "version": "6.9.1",
   "displayName": "Homebridge UniFi Protect",
   "description": "Homebridge UniFi Protect plugin providing complete HomeKit integration for the UniFi Protect ecosystem with full support for most features including autoconfiguration, motion detection, multiple controllers, and realtime updates.",
   "author": {
@@ -68,15 +68,15 @@
     "@homebridge/plugin-ui-utils": "^0.0.19",
     "ffmpeg-for-homebridge": "^0.1.4",
     "mqtt": "4.3.7",
-    "unifi-protect": "^4.2.4",
+    "unifi-protect": "^4.4.0",
     "ws": "^8.13.0"
   },
   "devDependencies": {
-    "@types/node": "^20.2.5",
-    "@types/ws": "^8.5.4",
-    "@typescript-eslint/eslint-plugin": "^5.59.8",
-    "@typescript-eslint/parser": "^5.59.8",
-    "eslint": "^8.42.0",
+    "@types/node": "^20.3.1",
+    "@types/ws": "^8.5.5",
+    "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "@typescript-eslint/parser": "^5.60.0",
+    "eslint": "^8.43.0",
     "homebridge": "=1.6.1",
     "nodemon": "^2.0.22",
     "rimraf": "^5.0.1",