homebridge-tydom 0.21.9

package/lib/accessories/securitySystem.js

@@ -0,0 +1,422 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSecuritySystem = exports.setupSecuritySystem = void 0;
+const lodash_1 = require("lodash");
+const env_1 = require("../config/env");
+const locale_1 = __importDefault(require("../config/locale"));
+const accessory_1 = require("../utils/accessory");
+const array_1 = require("../utils/array");
+const assert_1 = __importDefault(require("../utils/assert"));
+const chalk_1 = require("../utils/chalk");
+const debug_1 = __importStar(require("../utils/debug"));
+const hap_1 = require("../utils/hap");
+const hash_1 = require("../utils/hash");
+const tydom_1 = require("../utils/tydom");
+const getActiveZones = (alarmData) => alarmData.reduce((soFar, { name, value }) => {
+    const matches = name.match(/zone([1-8])State/i);
+    if (matches && value === 'ON') {
+        soFar.push(accessory_1.asNumber(matches[1]));
+    }
+    return soFar;
+}, []);
+const getStateForActiveZones = (activeZones, zoneAliases) => {
+    const { SecuritySystemCurrentState } = hap_1.Characteristic;
+    if (zoneAliases.stay && array_1.sameArrays(activeZones, zoneAliases.stay)) {
+        return SecuritySystemCurrentState.STAY_ARM;
+    }
+    if (zoneAliases.night && array_1.sameArrays(activeZones, zoneAliases.night)) {
+        return SecuritySystemCurrentState.NIGHT_ARM;
+    }
+    return SecuritySystemCurrentState.DISARMED;
+};
+const getStateForAlarmData = (alarmData, zoneAliases) => {
+    const { SecuritySystemCurrentState } = hap_1.Characteristic;
+    const alarmMode = tydom_1.getTydomDataPropValue(alarmData, 'alarmMode');
+    const alarmState = tydom_1.getTydomDataPropValue(alarmData, 'alarmState');
+    if (['DELAYED', 'ON', 'QUIET'].includes(alarmState)) {
+        return SecuritySystemCurrentState.ALARM_TRIGGERED;
+    }
+    if (alarmMode === 'ON') {
+        return SecuritySystemCurrentState.AWAY_ARM;
+    }
+    if (alarmMode === 'ZONE') {
+        const activeZones = getActiveZones(alarmData);
+        return getStateForActiveZones(activeZones, zoneAliases);
+    }
+    return SecuritySystemCurrentState.DISARMED;
+};
+const setupSecuritySystem = async (accessory, controller) => {
+    const { context } = accessory;
+    const { client } = controller;
+    const { SecuritySystemTargetState, SecuritySystemCurrentState, StatusTampered, ContactSensorState, On } = hap_1.Characteristic;
+    const { deviceId, endpointId, settings } = context;
+    accessory_1.setupAccessoryInformationService(accessory, controller);
+    accessory_1.setupAccessoryIdentifyHandler(accessory, controller);
+    const aliases = (settings.aliases || {});
+    // Create separate dedicated sensor extra accessory;
+    if (settings.sensors !== false) {
+        const { accessoryId } = context;
+        const extraDevice = {
+            ...context,
+            name: `${lodash_1.get(locale_1.default, 'ALARME_ISSUES_OUVERTES', 'N/A')}`,
+            category: accessory_1.SECURITY_SYSTEM_SENSORS,
+            accessoryId: `${accessoryId}:sensors`
+        };
+        controller.emit('device', extraDevice);
+    }
+    const initialData = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+    const labelResults = await client.command(`/devices/${deviceId}/endpoints/${endpointId}/cdata?name=label`);
+    const { zones } = labelResults[0];
+    // Pin code check
+    const pin = env_1.HOMEBRIDGE_TYDOM_PIN ? hash_1.decode(env_1.HOMEBRIDGE_TYDOM_PIN) : settings.pin;
+    if (!pin) {
+        controller.log.warn(`Missing pin for device securitySystem, add either {"settings": {"${deviceId}": {"pin": "123456"}}} or HOMEBRIDGE_TYDOM_PIN env var (base64 encoded)`);
+    }
+    // Add the actual accessory Service
+    const service = accessory_1.addAccessoryService(accessory, hap_1.Service.SecuritySystem, `${accessory.displayName}`, true);
+    service
+        .getCharacteristic(SecuritySystemCurrentState)
+        .setValue(SecuritySystemCurrentState.DISARMED) // Default to disarmed to prevent notifications
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(SecuritySystemCurrentState, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const nextValue = getStateForAlarmData(data, aliases);
+            debug_1.debugGetResult(SecuritySystemCurrentState, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+    service
+        .getCharacteristic(StatusTampered)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(StatusTampered, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const systAutoProtect = tydom_1.getTydomDataPropValue(data, 'systAutoProtect');
+            debug_1.debugGetResult(StatusTampered, service, systAutoProtect);
+            callback(null, systAutoProtect);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+    service
+        .getCharacteristic(SecuritySystemTargetState)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(SecuritySystemTargetState, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const nextValue = getStateForAlarmData(data, aliases);
+            debug_1.debugGetResult(SecuritySystemTargetState, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .on("set" /* SET */, async (value, callback) => {
+        debug_1.debugSet(SecuritySystemTargetState, service, value);
+        if (!pin) {
+            callback();
+            return;
+        }
+        // Clear preAlarm trigger
+        if ([SecuritySystemTargetState.DISARM].includes(value)) {
+            preAlarmService.updateCharacteristic(ContactSensorState, false);
+        }
+        // Global ON/OFF
+        if ([SecuritySystemTargetState.AWAY_ARM, SecuritySystemTargetState.DISARM].includes(value)) {
+            const tydomValue = value === SecuritySystemTargetState.DISARM ? 'OFF' : 'ON';
+            await client.put(`/devices/${deviceId}/endpoints/${endpointId}/cdata?name=alarmCmd`, {
+                value: tydomValue,
+                pwd: pin
+            });
+            debug_1.debugSetResult(SecuritySystemTargetState, service, value, tydomValue);
+            callback();
+            return;
+        }
+        // Zones ON/OFF
+        if ([SecuritySystemTargetState.STAY_ARM, SecuritySystemTargetState.NIGHT_ARM].includes(value)) {
+            const tydomValue = value === SecuritySystemTargetState.DISARM ? 'OFF' : 'ON';
+            const targetZones = value === SecuritySystemTargetState.STAY_ARM ? aliases.stay : aliases.night;
+            if (Array.isArray(targetZones) && targetZones.length > 0) {
+                await client.put(`/devices/${deviceId}/endpoints/${endpointId}/cdata?name=zoneCmd`, {
+                    value: tydomValue,
+                    pwd: pin,
+                    zones: targetZones
+                });
+            }
+            debug_1.debugSetResult(SecuritySystemTargetState, service, value, tydomValue);
+            callback();
+            return;
+        }
+    });
+    // Setup systOpenIssue contactSensor
+    const systOpenIssueId = `systOpenIssue`;
+    const systOpenIssueName = lodash_1.get(locale_1.default, 'ALARME_ISSUES_OUVERTES', 'N/A');
+    const systOpenIssueService = accessory_1.addAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, systOpenIssueName, systOpenIssueId, true);
+    debug_1.debugAddSubService(systOpenIssueService, accessory);
+    service.addLinkedService(systOpenIssueService);
+    systOpenIssueService
+        .getCharacteristic(ContactSensorState)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(ContactSensorState, systOpenIssueService);
+        try {
+            const data = (await tydom_1.getTydomDeviceData(client, { deviceId, endpointId }));
+            const systOpenIssue = tydom_1.getTydomDataPropValue(data, 'systOpenIssue');
+            debug_1.debugGetResult(ContactSensorState, systOpenIssueService, systOpenIssue);
+            callback(null, systOpenIssue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    });
+    systOpenIssueService.getCharacteristic(hap_1.Characteristic.StatusActive).setValue(true);
+    systOpenIssueService.getCharacteristic(hap_1.Characteristic.StatusFault).setValue(false);
+    // Setup alarmSOS contactSensor
+    const alarmSOSId = `alarmSOS`;
+    const alarmSOSName = lodash_1.get(locale_1.default, 'DISCRETE_ALARM_V3', 'N/A');
+    const alarmSOSService = accessory_1.addAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, alarmSOSName, alarmSOSId, true);
+    debug_1.debugAddSubService(alarmSOSService, accessory);
+    service.addLinkedService(alarmSOSService);
+    alarmSOSService
+        .getCharacteristic(ContactSensorState)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(ContactSensorState, alarmSOSService);
+        try {
+            const data = (await tydom_1.getTydomDeviceData(client, { deviceId, endpointId }));
+            const alarmSOS = tydom_1.getTydomDataPropValue(data, 'alarmSOS');
+            debug_1.debugGetResult(ContactSensorState, alarmSOSService, alarmSOS);
+            callback(null, alarmSOS);
+        }
+        catch (err) {
+            callback(err);
+        }
+    });
+    alarmSOSService.getCharacteristic(hap_1.Characteristic.StatusActive).setValue(true);
+    alarmSOSService.getCharacteristic(hap_1.Characteristic.StatusFault).setValue(false);
+    // Setup preAlarm contactSensor
+    const preAlarmId = `preAlarm`;
+    const preAlarmName = lodash_1.get(locale_1.default, 'PREALARM', 'N/A');
+    const preAlarmService = accessory_1.addAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, preAlarmName, preAlarmId, true);
+    debug_1.debugAddSubService(preAlarmService, accessory);
+    service.addLinkedService(preAlarmService);
+    preAlarmService.getCharacteristic(ContactSensorState).setValue(false);
+    preAlarmService.getCharacteristic(hap_1.Characteristic.StatusActive).setValue(true);
+    preAlarmService.getCharacteristic(hap_1.Characteristic.StatusFault).setValue(false);
+    // Setup zones switches
+    for (let zoneIndex = 1; zoneIndex < 9; zoneIndex++) {
+        const zoneState = tydom_1.getTydomDataPropValue(initialData, `zone${zoneIndex}State`);
+        if (zoneState === 'UNUSED') {
+            continue;
+        }
+        assert_1.default(zones[zoneIndex - 1], `Unexpected missing zone label data for index ${zoneIndex}`);
+        const { id: productId, nameStd, nameCustom } = zones[zoneIndex - 1];
+        const subDeviceId = `zone_${productId}`;
+        const subDeviceName = nameCustom || `${nameStd ? lodash_1.get(locale_1.default, nameStd, 'N/A') : `Zone ${zoneIndex}`}`;
+        const zoneService = accessory_1.addAccessoryServiceWithSubtype(accessory, hap_1.Service.Switch, subDeviceName, subDeviceId, true);
+        debug_1.debugAddSubService(zoneService, accessory);
+        service.addLinkedService(zoneService);
+        zoneService
+            .getCharacteristic(On)
+            .on("get" /* GET */, async (callback) => {
+            debug_1.debugGet(On, zoneService);
+            try {
+                const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+                const zoneState = tydom_1.getTydomDataPropValue(data, `zone${zoneIndex}State`);
+                const nextValue = zoneState === 'ON';
+                debug_1.debugGetResult(On, zoneService, nextValue);
+                callback(null, nextValue);
+            }
+            catch (err) {
+                callback(err);
+            }
+        })
+            .on("set" /* SET */, async (value, callback) => {
+            debug_1.debugSet(On, zoneService, value);
+            if (!pin) {
+                callback();
+                return;
+            }
+            const tydomValue = value ? 'ON' : 'OFF';
+            await client.put(`/devices/${deviceId}/endpoints/${endpointId}/cdata?name=zoneCmd`, {
+                value: tydomValue,
+                pwd: pin,
+                zones: [zoneIndex]
+            });
+            debug_1.debugSetResult(On, zoneService, value, tydomValue);
+            callback();
+        });
+    }
+};
+exports.setupSecuritySystem = setupSecuritySystem;
+const updateSecuritySystem = (accessory, controller, updates, type) => {
+    // Relay to separate dedicated sensor extra accessory;
+    const { deviceId, endpointId, accessoryId, settings } = accessory.context;
+    const aliases = (settings.aliases || {});
+    const { SecuritySystemCurrentState, ContactSensorState, On } = hap_1.Characteristic;
+    if (settings.sensors !== false) {
+        const extraUpdateContext = {
+            category: accessory_1.SECURITY_SYSTEM_SENSORS,
+            deviceId,
+            endpointId,
+            accessoryId: `${accessoryId}:sensors`
+        };
+        controller.emit('update', {
+            type,
+            updates,
+            context: extraUpdateContext
+        });
+    }
+    // Process command updates
+    if (type === 'cdata') {
+        updates.forEach((update) => {
+            const { name, parameters, values } = update;
+            // Notify with webhooks
+            switch (name) {
+                case 'eventAlarm': {
+                    const { event } = values;
+                    debug_1.default(`New ${chalk_1.chalkKeyword('SecuritySystem')} alarm event=${chalk_1.chalkJson(event)}`);
+                    controller.emit('notification', {
+                        level: 'warn',
+                        message: `SecuritySystem \`${name}\` event, name=\`${event.name}\` parameters=\`${JSON.stringify(parameters)}\`, values=\`${JSON.stringify(values)}\``
+                    });
+                    switch (event.name) {
+                        case 'arret': {
+                            const service = accessory_1.getAccessoryService(accessory, hap_1.Service.SecuritySystem);
+                            debug_1.debugSetUpdate(SecuritySystemCurrentState, service, SecuritySystemCurrentState.DISARMED);
+                            service.updateCharacteristic(SecuritySystemCurrentState, SecuritySystemCurrentState.DISARMED);
+                            return;
+                        }
+                        case 'marcheTotale': {
+                            const service = accessory_1.getAccessoryService(accessory, hap_1.Service.SecuritySystem);
+                            debug_1.debugSetUpdate(SecuritySystemCurrentState, service, SecuritySystemCurrentState.AWAY_ARM);
+                            service.updateCharacteristic(SecuritySystemCurrentState, SecuritySystemCurrentState.AWAY_ARM);
+                            return;
+                        }
+                        case 'marcheZone': {
+                            const service = accessory_1.getAccessoryService(accessory, hap_1.Service.SecuritySystem);
+                            const activeZones = event.zones.map((zone) => zone.id + 1);
+                            const nextValue = getStateForActiveZones(activeZones, aliases);
+                            debug_1.debugSetUpdate(SecuritySystemCurrentState, service, nextValue);
+                            service.updateCharacteristic(SecuritySystemCurrentState, nextValue);
+                            return;
+                        }
+                        case 'preAlarm': {
+                            const service = accessory_1.getAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, 'preAlarm');
+                            debug_1.debugSetUpdate(ContactSensorState, service, true);
+                            service.updateCharacteristic(ContactSensorState, true);
+                            return;
+                        }
+                        default: {
+                            return;
+                        }
+                    }
+                }
+                default: {
+                    controller.emit('notification', {
+                        level: 'debug',
+                        message: `SecuritySystem \`${name}\` event parameters=\`${JSON.stringify(parameters)}\`, values=\`${JSON.stringify(values)}\``
+                    });
+                    return;
+                }
+            }
+        });
+        return;
+    }
+    updates.forEach((update) => {
+        const { name, value } = update;
+        switch (name) {
+            case 'alarmMode': {
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.SecuritySystem);
+                switch (value) {
+                    case 'OFF': {
+                        const nextValue = SecuritySystemCurrentState.DISARMED;
+                        debug_1.debugSetUpdate(SecuritySystemCurrentState, service, nextValue);
+                        service.updateCharacteristic(SecuritySystemCurrentState, nextValue);
+                        return;
+                    }
+                    case 'ON': {
+                        const nextValue = SecuritySystemCurrentState.AWAY_ARM;
+                        debug_1.debugSetUpdate(SecuritySystemCurrentState, service, nextValue);
+                        service.updateCharacteristic(SecuritySystemCurrentState, nextValue);
+                        return;
+                    }
+                    case 'ZONE': {
+                        const activeZones = getActiveZones(updates);
+                        const nextValue = getStateForActiveZones(activeZones, aliases);
+                        debug_1.debugSetUpdate(SecuritySystemCurrentState, service, nextValue);
+                        service.updateCharacteristic(SecuritySystemCurrentState, nextValue);
+                        return;
+                    }
+                    default:
+                        return;
+                }
+            }
+            case 'alarmSOS': {
+                const service = accessory_1.getAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, 'alarmSOS');
+                const alarmSOS = !!value;
+                debug_1.debugSetUpdate(ContactSensorState, service, alarmSOS);
+                service.updateCharacteristic(ContactSensorState, alarmSOS);
+                return;
+            }
+            case 'zone1State':
+            case 'zone2State':
+            case 'zone3State':
+            case 'zone4State':
+            case 'zone5State':
+            case 'zone6State':
+            case 'zone7State':
+            case 'zone8State': {
+                const zoneState = value;
+                if (zoneState === 'UNUSED') {
+                    return;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const zoneIndex = parseInt(name.match(/zone(\d+)State/)[1], 10) - 1; // @NOTE Adjust for productId starting at 0
+                const service = accessory_1.getAccessoryServiceWithSubtype(accessory, hap_1.Service.Switch, `zone_${zoneIndex}`);
+                const nextValue = zoneState === 'ON';
+                debug_1.debugSetUpdate(On, service, nextValue);
+                service.updateCharacteristic(On, nextValue);
+                return;
+            }
+            case 'systOpenIssue': {
+                const service = accessory_1.getAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, 'systOpenIssue');
+                const systOpenIssue = !!value;
+                debug_1.debugSetUpdate(ContactSensorState, service, systOpenIssue);
+                service.updateCharacteristic(ContactSensorState, systOpenIssue);
+                return;
+            }
+            default:
+                return;
+        }
+    });
+};
+exports.updateSecuritySystem = updateSecuritySystem;

package/lib/accessories/securitySystemSensors.d.ts

@@ -0,0 +1,5 @@
+import type { PlatformAccessory } from 'homebridge';
+import TydomController from '../controller';
+import { TydomAccessoryUpdateType } from '../utils/accessory';
+export declare const setupSecuritySystemSensors: (accessory: PlatformAccessory, controller: TydomController) => Promise<void>;
+export declare const updateSecuritySystemSensors: (accessory: PlatformAccessory, controller: TydomController, updates: Record<string, unknown>[], type: TydomAccessoryUpdateType) => void;

package/lib/accessories/securitySystemSensors.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSecuritySystemSensors = exports.setupSecuritySystemSensors = void 0;
+const lodash_1 = require("lodash");
+const locale_1 = __importDefault(require("../config/locale"));
+const accessory_1 = require("../utils/accessory");
+const debug_1 = require("../utils/debug");
+const hap_1 = require("../utils/hap");
+const tydom_1 = require("../utils/tydom");
+const getOpenedIssues = (commandResults) => lodash_1.keyBy(
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+commandResults.filter((result) => result.product).map((result) => result.product), 'id');
+let contactSensorProducts = [];
+let histoSearchParams;
+const setupSecuritySystemSensors = async (accessory, controller) => {
+    const { context } = accessory;
+    const { client } = controller;
+    const { ContactSensorState } = hap_1.Characteristic;
+    const { deviceId, endpointId } = context;
+    accessory_1.setupAccessoryInformationService(accessory, controller);
+    accessory_1.setupAccessoryIdentifyHandler(accessory, controller);
+    const labelResults = await client.command(`/devices/${deviceId}/endpoints/${endpointId}/cdata?name=label`);
+    const { products } = labelResults[0];
+    contactSensorProducts = products.filter((product) => ['MDO'].includes(product.typeLong));
+    histoSearchParams = { type: 'OPEN_ISSUES', indexStart: '0', nbElem: `${contactSensorProducts.length}` };
+    const initialOpenedIssues = getOpenedIssues(await tydom_1.runTydomDeviceCommand(client, 'histo', {
+        deviceId,
+        endpointId,
+        searchParams: histoSearchParams
+    }));
+    contactSensorProducts.forEach((contactSensorProduct) => {
+        const { id: productId, nameStd, nameCustom, number } = contactSensorProduct;
+        const subDeviceId = `systOpenIssue_${productId}`;
+        const subDeviceName = nameCustom || `${lodash_1.get(locale_1.default, nameStd, 'N/A')}${number ? ` ${number}` : ''}`;
+        const contactSensorService = accessory_1.addAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, subDeviceName, subDeviceId, true);
+        debug_1.debugAddSubService(contactSensorService, accessory);
+        // service.addLinkedService(contactSensorService); // @TODO ServiceLabel?
+        contactSensorService
+            .getCharacteristic(ContactSensorState)
+            .setValue(initialOpenedIssues[productId] ? 1 : 0)
+            .on("get" /* GET */, async (callback) => {
+            debug_1.debugGet(ContactSensorState, contactSensorService);
+            try {
+                const openedIssues = getOpenedIssues(await tydom_1.runTydomDeviceCommand(client, 'histo', {
+                    deviceId,
+                    endpointId,
+                    searchParams: histoSearchParams
+                }));
+                const nextValue = openedIssues[productId] ? 1 : 0;
+                debug_1.debugGetResult(ContactSensorState, contactSensorService, nextValue);
+                callback(null, nextValue);
+            }
+            catch (err) {
+                callback(err);
+            }
+        });
+        contactSensorService.getCharacteristic(hap_1.Characteristic.StatusActive).setValue(1);
+        contactSensorService.getCharacteristic(hap_1.Characteristic.StatusFault).setValue(0);
+    });
+};
+exports.setupSecuritySystemSensors = setupSecuritySystemSensors;
+const updateSecuritySystemSensors = (accessory, controller, updates, type) => {
+    const { client } = controller;
+    // Process command updates
+    if (type === 'cdata') {
+        return;
+    }
+    updates.forEach(async (update) => {
+        const { context } = accessory;
+        const { deviceId, endpointId } = context;
+        const { ContactSensorState } = hap_1.Characteristic;
+        const { name, value } = update;
+        switch (name) {
+            case 'systOpenIssue': {
+                const systOpenIssue = value;
+                if (!systOpenIssue) {
+                    contactSensorProducts.forEach(({ id: productId }) => {
+                        const subDeviceId = `systOpenIssue_${productId}`;
+                        const service = accessory_1.getAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, subDeviceId);
+                        const nextValue = 0;
+                        debug_1.debugSetUpdate(ContactSensorState, service, nextValue);
+                        service.updateCharacteristic(ContactSensorState, nextValue);
+                    });
+                }
+                else {
+                    const openedIssues = getOpenedIssues(await tydom_1.runTydomDeviceCommand(client, 'histo', {
+                        deviceId,
+                        endpointId,
+                        searchParams: histoSearchParams
+                    }));
+                    contactSensorProducts.forEach(({ id: productId }) => {
+                        const subDeviceId = `systOpenIssue_${productId}`;
+                        const service = accessory_1.getAccessoryServiceWithSubtype(accessory, hap_1.Service.ContactSensor, subDeviceId);
+                        const nextValue = openedIssues[productId] ? 1 : 0;
+                        debug_1.debugSetUpdate(ContactSensorState, service, nextValue);
+                        service.updateCharacteristic(ContactSensorState, nextValue);
+                    });
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    });
+};
+exports.updateSecuritySystemSensors = updateSecuritySystemSensors;
+/*
+{
+  initialOpenedIssues: [
+    {
+      step: 0,
+      nbElemTot: 2,
+      index: 16,
+      product: {
+        typeShort: 'MDO',
+        typeLong: 'MDO',
+        id: 16,
+        nameStd: 'BASEMENT',
+        number: 3
+      }
+    },
+    {
+      step: 1,
+      nbElemTot: 2,
+      index: 17,
+      product: {
+        typeShort: 'MDO',
+        typeLong: 'MDO',
+        id: 17,
+        nameStd: 'BASEMENT',
+        number: 2
+      }
+    },
+    { step: 2, nbElemTot: 2, index: 51 }
+  ]
+}
+*/
+/*
+{
+  openedIssues: {
+    '16': {
+      typeShort: 'MDO',
+      typeLong: 'MDO',
+      id: 16,
+      nameStd: 'BASEMENT',
+      number: 3
+    },
+    '17': {
+      typeShort: 'MDO',
+      typeLong: 'MDO',
+      id: 17,
+      nameStd: 'BASEMENT',
+      number: 2
+    }
+  }
+}
+*/

package/lib/accessories/services/switchableService.d.ts

@@ -0,0 +1,5 @@
+import type { PlatformAccessory, Service } from 'homebridge';
+import TydomController from '../../controller';
+import { ServiceClass } from '../../utils/accessory';
+export declare const addAccessorySwitchableService: (accessory: PlatformAccessory, controller: TydomController, serviceClass: ServiceClass) => Service;
+export declare const updateAccessorySwitchableService: (accessory: PlatformAccessory, _controller: TydomController, updates: Record<string, unknown>[], ServiceClass: ServiceClass) => void;

package/lib/accessories/services/switchableService.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAccessorySwitchableService = exports.addAccessorySwitchableService = void 0;
+const accessory_1 = require("../../utils/accessory");
+const debug_1 = require("../../utils/debug");
+const hap_1 = require("../../utils/hap");
+const tydom_1 = require("../../utils/tydom");
+const addAccessorySwitchableService = (accessory, controller, serviceClass) => {
+    const { context } = accessory;
+    const { client } = controller;
+    const { On } = hap_1.Characteristic;
+    const { deviceId, endpointId } = context;
+    const service = accessory_1.addAccessoryService(accessory, serviceClass, `${accessory.displayName}`, true);
+    service
+        .getCharacteristic(On)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(On, service);
+        try {
+            const data = (await tydom_1.getTydomDeviceData(client, { deviceId, endpointId }));
+            const level = tydom_1.getTydomDataPropValue(data, 'level');
+            const nextValue = level === 100;
+            debug_1.debugGetResult(On, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .on("set" /* SET */, async (value, callback) => {
+        debug_1.debugSet(On, service, value);
+        try {
+            const tydomValue = value ? 100 : 0;
+            await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+                {
+                    name: 'level',
+                    value: tydomValue
+                }
+            ]);
+            debug_1.debugSetResult(On, service, value, tydomValue);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    });
+    return service;
+};
+exports.addAccessorySwitchableService = addAccessorySwitchableService;
+const updateAccessorySwitchableService = (accessory, _controller, updates, ServiceClass) => {
+    updates.forEach((update) => {
+        const { name, value } = update;
+        const { On } = hap_1.Characteristic;
+        switch (name) {
+            case 'level': {
+                const service = accessory_1.getAccessoryService(accessory, ServiceClass);
+                const nextValue = value === 100;
+                debug_1.debugSetUpdate(On, service, nextValue);
+                service.updateCharacteristic(On, nextValue);
+                return;
+            }
+            default:
+                return;
+        }
+    });
+};
+exports.updateAccessorySwitchableService = updateAccessorySwitchableService;

package/lib/accessories/switch.d.ts

@@ -0,0 +1,4 @@
+import TydomController from '../controller';
+import type { PlatformAccessory } from 'homebridge';
+export declare const setupSwitch: (accessory: PlatformAccessory, controller: TydomController) => void;
+export declare const updateSwitch: (accessory: PlatformAccessory, controller: TydomController, updates: Record<string, unknown>[]) => void;