@rfranzoi/scrypted-mqtt-securitysystem 1.0.36 → 1.0.38

package/dist/main.nodejs.js

@@ -34062,6 +34062,24 @@ function falsy(v) {
 }
 function normalize(s) { return (s || '').trim().toLowerCase(); }
 function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
+function deepEqual(a, b) {
+    try {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    catch {
+        return a === b;
+    }
+}
+/** Imposta una property e, se cambia, emette anche l'evento Scrypted corrispondente */
+function setAndEmit(dev, key, value, iface) {
+    if (dev[key] === value)
+        return;
+    dev[key] = value;
+    try {
+        dev.onDeviceEvent?.(iface, value);
+    }
+    catch { }
+}
 /** Outgoing predefiniti (PAI-like). Chiavi numeriche per compatibilità enum */
 const DEFAULT_OUTGOING = {
     [SecuritySystemMode.Disarmed]: 'disarm',
@@ -34094,46 +34112,145 @@ class BaseMqttSensor extends ScryptedDeviceBase {
     handleMqtt(topic, payload) {
         const p = payload?.toString() ?? '';
         const np = normalize(p);
+        // Online
         if (topic === this.cfg.topics.online) {
             if (truthy(np) || np === 'online')
-                this.online = true;
+                setAndEmit(this, 'online', true, ScryptedInterface.Online);
             if (falsy(np) || np === 'offline')
-                this.online = false;
+                setAndEmit(this, 'online', false, ScryptedInterface.Online);
         }
+        // Tamper
         if (topic === this.cfg.topics.tamper) {
             if (truthy(np) || ['tamper', 'intrusion', 'cover', 'motion', 'magnetic'].includes(np)) {
-                this.tampered = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+                const t = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+                setAndEmit(this, 'tampered', t, ScryptedInterface.TamperSensor);
             }
             else if (falsy(np))
-                this.tampered = false;
+                setAndEmit(this, 'tampered', false, ScryptedInterface.TamperSensor);
         }
+        // Battery
         if (topic === this.cfg.topics.batteryLevel) {
             const n = clamp(parseFloat(p), 0, 100);
             if (isFinite(n))
-                this.batteryLevel = n;
+                setAndEmit(this, 'batteryLevel', n, ScryptedInterface.Battery);
         }
         else if (topic === this.cfg.topics.lowBattery && !this.cfg.topics.batteryLevel) {
-            this.batteryLevel = truthy(np) ? 10 : 100;
+            const n = truthy(np) ? 10 : 100;
+            setAndEmit(this, 'batteryLevel', n, ScryptedInterface.Battery);
         }
+        // Primary
         this.handlePrimary(topic, np, p);
     }
 }
+/** === SENSORI CON PARSING ROBUSTO + EMISSIONE EVENTI === */
 class ContactMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
-        if (topic === this.cfg.topics.contact)
-            this.entryOpen = truthy(np);
+    handlePrimary(topic, np, raw) {
+        if (topic !== this.cfg.topics.contact)
+            return;
+        let val;
+        // stringhe comuni
+        if (['open', 'opened', '1', 'true', 'on', 'yes'].includes(np))
+            val = true;
+        else if (['closed', 'close', '0', 'false', 'off', 'no', 'shut'].includes(np))
+            val = false;
+        // JSON comuni
+        if (val === undefined) {
+            try {
+                const j = JSON.parse(raw);
+                if (typeof j?.open === 'boolean')
+                    val = !!j.open;
+                else if (typeof j?.opened === 'boolean')
+                    val = !!j.opened;
+                else if (typeof j?.contact === 'boolean')
+                    val = !j.contact; // contact:false => OPEN
+                else if (typeof j?.state === 'string') {
+                    const s = String(j.state).toLowerCase();
+                    if (s === 'open')
+                        val = true;
+                    if (s === 'closed')
+                        val = false;
+                }
+            }
+            catch { }
+        }
+        if (val !== undefined) {
+            setAndEmit(this, 'entryOpen', val, ScryptedInterface.EntrySensor);
+        }
+        else {
+            this.console?.debug?.(`Contact payload non gestito (${this.cfg.id}): "${raw}"`);
+        }
     }
 }
 class MotionMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
-        if (topic === this.cfg.topics.motion)
-            this.motionDetected = truthy(np);
+    handlePrimary(topic, np, raw) {
+        if (topic !== this.cfg.topics.motion)
+            return;
+        let val;
+        if (['motion', 'detected', 'active', '1', 'true', 'on', 'yes'].includes(np))
+            val = true;
+        else if (['clear', 'inactive', 'no_motion', 'none', '0', 'false', 'off', 'no'].includes(np))
+            val = false;
+        if (val === undefined) {
+            try {
+                const j = JSON.parse(raw);
+                if (typeof j?.motion === 'boolean')
+                    val = !!j.motion;
+                else if (typeof j?.occupancy === 'boolean')
+                    val = !!j.occupancy;
+                else if (typeof j?.presence === 'boolean')
+                    val = !!j.presence;
+                else if (typeof j?.state === 'string') {
+                    const s = String(j.state).toLowerCase();
+                    if (['on', 'motion', 'detected', 'active'].includes(s))
+                        val = true;
+                    if (['off', 'clear', 'inactive'].includes(s))
+                        val = false;
+                }
+            }
+            catch { }
+        }
+        if (val !== undefined) {
+            setAndEmit(this, 'motionDetected', val, ScryptedInterface.MotionSensor);
+        }
+        else {
+            this.console?.debug?.(`Motion payload non gestito (${this.cfg.id}): "${raw}"`);
+        }
     }
 }
 class OccupancyMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
-        if (topic === this.cfg.topics.occupancy)
-            this.occupied = truthy(np);
+    handlePrimary(topic, np, raw) {
+        if (topic !== this.cfg.topics.occupancy)
+            return;
+        let val;
+        if (['occupied', 'presence', 'present', '1', 'true', 'on', 'yes'].includes(np))
+            val = true;
+        else if (['unoccupied', 'vacant', 'absent', '0', 'false', 'off', 'no', 'clear'].includes(np))
+            val = false;
+        if (val === undefined) {
+            try {
+                const j = JSON.parse(raw);
+                if (typeof j?.occupied === 'boolean')
+                    val = !!j.occupied;
+                else if (typeof j?.presence === 'boolean')
+                    val = !!j.presence;
+                else if (typeof j?.occupancy === 'boolean')
+                    val = !!j.occupancy;
+                else if (typeof j?.state === 'string') {
+                    const s = String(j.state).toLowerCase();
+                    if (['occupied', 'presence', 'present', 'on'].includes(s))
+                        val = true;
+                    if (['vacant', 'absent', 'clear', 'off'].includes(s))
+                        val = false;
+                }
+            }
+            catch { }
+        }
+        if (val !== undefined) {
+            setAndEmit(this, 'occupied', val, ScryptedInterface.OccupancySensor);
+        }
+        else {
+            this.console?.debug?.(`Occupancy payload non gestito (${this.cfg.id}): "${raw}"`);
+        }
     }
 }
 /** ----------------- Main Plugin ----------------- */
@@ -34142,8 +34259,8 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         super();
         this.sensorsCfg = [];
         this.devices = new Map();
-        // evitiamo spam: ricordiamo se abbiamo già provato ad annunciare
-        this.triedDiscoveryOnce = false;
+        // Evita loop di log: tenta una volta finché deviceManager non c’è, poi riprova su eventi utili.
+        this.discoveryPostponed = false;
         // Tipo in UI (best-effort)
         setTimeout(() => {
             try {
@@ -34323,17 +34440,17 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
     safeDiscoverSensors(triggeredByChange = false) {
         const dmAny = sdk?.deviceManager;
         if (!dmAny) {
-            if (!this.triedDiscoveryOnce) {
+            // Posticipa una sola volta; poi riproviamo su connect MQTT e al primo messaggio
+            if (!this.discoveryPostponed) {
                 this.console.log('Device discovery postponed: deviceManager not ready yet.');
-                this.triedDiscoveryOnce = true;
+                this.discoveryPostponed = true;
             }
-            // Riprovaremo in due casi: a) settaggi cambiati (già chiama safeDiscoverSensors)
-            // b) al primo messaggio MQTT (vedi handler sotto).
             return;
         }
-        // Se arriviamo qui, il manager c’è: esegui discover.
-        this.triedDiscoveryOnce = false;
+        this.discoveryPostponed = false;
         this.discoverSensors(dmAny);
+        if (triggeredByChange)
+            this.console.log('Sensors discovered/updated.');
     }
     /** discoverSensors con deviceManager garantito */
     discoverSensors(dmAny) {
@@ -34380,7 +34497,7 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             }
             const hasBattery = !!(cfg.topics.batteryLevel || cfg.topics.lowBattery);
             if (hasBattery && dev.batteryLevel === undefined)
-                dev.batteryLevel = 100;
+                setAndEmit(dev, 'batteryLevel', 100, ScryptedInterface.Battery);
         }
         // 4) Cleanup
         const announced = new Set(manifests.map(m => m.nativeId));
@@ -34445,7 +34562,7 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         const tOnline = this.storage.getItem('topicOnline') || '';
         client.on('connect', () => {
             this.console.log('MQTT connected');
-            this.online = true;
+            setAndEmit(this, 'online', true, ScryptedInterface.Online);
             if (subs.length)
                 client.subscribe(subs, { qos: 0 }, (err) => { if (err)
                     this.console.error('subscribe error', err); });
@@ -34453,7 +34570,7 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             this.safeDiscoverSensors(true);
         });
         client.on('reconnect', () => this.console.log('MQTT reconnecting...'));
-        client.on('close', () => { this.console.log('MQTT closed'); this.online = false; });
+        client.on('close', () => { this.console.log('MQTT closed'); setAndEmit(this, 'online', false, ScryptedInterface.Online); });
         client.on('error', (e) => { this.console.error('MQTT error', e); });
         client.on('message', (topic, payload) => {
             try {
@@ -34461,23 +34578,26 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                 const np = normalize(p);
                 if (topic === tOnline) {
                     if (truthy(np) || np === 'online')
-                        this.online = true;
+                        setAndEmit(this, 'online', true, ScryptedInterface.Online);
                     if (falsy(np) || np === 'offline')
-                        this.online = false;
+                        setAndEmit(this, 'online', false, ScryptedInterface.Online);
                     return;
                 }
                 if (topic === tTamper) {
-                    if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np))
-                        this.tampered = ['cover', 'intrusion'].find(x => x === np) || true;
-                    else if (falsy(np))
-                        this.tampered = false;
+                    if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np)) {
+                        const t = ['cover', 'intrusion'].find(x => x === np) || true;
+                        setAndEmit(this, 'tampered', t, ScryptedInterface.TamperSensor);
+                    }
+                    else if (falsy(np)) {
+                        setAndEmit(this, 'tampered', false, ScryptedInterface.TamperSensor);
+                    }
                     return;
                 }
                 if (topic === tCurrent) {
                     const mode = payloadToMode(payload);
                     const isAlarm = ['alarm', 'triggered'].includes(np);
                     const current = this.securitySystemState || { mode: SecuritySystemMode.Disarmed };
-                    this.securitySystemState = {
+                    const newState = {
                         mode: mode ?? current.mode,
                         supportedModes: current.supportedModes ?? [
                             SecuritySystemMode.Disarmed,
@@ -34487,6 +34607,13 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                         ],
                         triggered: isAlarm || undefined,
                     };
+                    if (!deepEqual(this.securitySystemState, newState)) {
+                        this.securitySystemState = newState;
+                        try {
+                            this.onDeviceEvent?.(ScryptedInterface.SecuritySystem, newState);
+                        }
+                        catch { }
+                    }
                     return;
                 }
                 if (topic === tTarget) {
@@ -34495,8 +34622,8 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
                     return;
                 }
                 // Dispatch ai sensori
-                // (E prova ad annunciare se non l’abbiamo ancora fatto e ora il manager è pronto)
-                if (this.triedDiscoveryOnce)
+                // (E prova ad annunciare se era stato posticipato e ora il manager è pronto)
+                if (this.discoveryPostponed)
                     this.safeDiscoverSensors(true);
                 for (const dev of this.devices.values())
                     dev.handleMqtt(topic, payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfranzoi/scrypted-mqtt-securitysystem",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "Scrypted plugin: Paradox Security System via MQTT (PAI/PAI-MQTT style).",
   "license": "MIT",
   "main": "dist/main.nodejs.js",