iobroker.loxone 3.0.0 → 4.0.0

package/package.json

@@ -1,78 +1,74 @@
 {
   "name": "iobroker.loxone",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Communicates with a Loxone Miniserver.",
   "author": {
     "name": "UncleSamSwiss",
     "email": "samuel.weibel@gmail.com"
   },
+  "contributors": [
+    {
+      "name": "Robin Rainton",
+      "email": "robin@rainton.com"
+    }
+  ],
   "homepage": "https://github.com/UncleSamSwiss/ioBroker.loxone",
   "license": "Apache-2.0",
   "keywords": [
+    "ioBroker",
     "loxone",
     "miniserver",
     "smarthome"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/UncleSamSwiss/ioBroker.loxone"
+    "url": "https://github.com/UncleSamSwiss/ioBroker.loxone.git"
+  },
+  "engines": {
+    "node": ">= 20"
   },
   "dependencies": {
-    "@iobroker/adapter-core": "^2.5.1",
-    "@sentry/node": "^6.16.1",
-    "axios": "^0.24.0",
-    "color-convert": "^2.0.1",
-    "form-data": "^4.0.0",
+    "@iobroker/adapter-core": "^3.3.2",
+    "axios": "^1.4.0",
+    "color-convert": "^3.1.3",
+    "form-data": "^4.0.4",
     "lxcommunicator": "^1.1.1",
-    "queue-fifo": "*",
+    "queue-fifo": "^0.2.6",
     "sprintf-js": "^1.1.2",
-    "uuid": "^8.3.2"
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@alcalzone/release-script": "^2.2.1",
-    "@iobroker/adapter-dev": "^0.1.0",
-    "@iobroker/testing": "^2.5.2",
-    "@types/chai": "^4.2.22",
-    "@types/chai-as-promised": "^7.1.4",
-    "@types/color-convert": "^2.0.0",
-    "@types/mocha": "^9.0.0",
-    "@types/node": "^16.11.17",
-    "@types/proxyquire": "^1.3.28",
-    "@types/sinon": "^10.0.6",
-    "@types/sinon-chai": "^3.2.7",
-    "@types/sprintf-js": "^1.1.2",
-    "@types/uuid": "^8.3.3",
-    "@typescript-eslint/eslint-plugin": "^5.8.1",
-    "@typescript-eslint/parser": "^5.8.1",
-    "chai": "^4.3.4",
-    "chai-as-promised": "^7.1.1",
-    "eslint": "^8.5.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "mocha": "^9.1.3",
-    "prettier": "^2.5.0",
-    "proxyquire": "^2.1.3",
-    "rimraf": "^3.0.2",
-    "sinon": "^12.0.1",
-    "sinon-chai": "^3.7.0",
+    "@alcalzone/release-script": "^5.0.0",
+    "@alcalzone/release-script-plugin-iobroker": "^4.0.0",
+    "@alcalzone/release-script-plugin-license": "^4.0.0",
+    "@alcalzone/release-script-plugin-manual-review": "^4.0.0",
+    "@iobroker/adapter-dev": "^1.5.0",
+    "@iobroker/eslint-config": "^2.2.0",
+    "@iobroker/testing": "^5.2.2",
+    "@tsconfig/node20": "^20.1.8",
+    "@types/iobroker": "npm:@iobroker/types@^7.1.0",
+    "@types/node": "^20.19.26",
+    "@types/sprintf-js": "^1.1.4",
     "source-map-support": "^0.5.21",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.5.4"
+    "ts-node": "^10.9.2",
+    "typescript": "~5.9.3"
   },
-  "main": "build/main.js",
+  "main": "src/main.ts",
+  "files": [
+    "admin{,/!(src)/**}/!(tsconfig|tsconfig.*|.eslintrc).{json,json5}",
+    "admin{,/!(src)/**}/*.{html,css,png,svg,jpg,js}",
+    "src/",
+    "www/",
+    "io-package.json",
+    "LICENSE"
+  ],
   "scripts": {
-    "prebuild": "rimraf ./build",
-    "build:ts": "tsc -p tsconfig.build.json",
-    "build": "npm run build:ts",
-    "watch:ts": "tsc -p tsconfig.build.json --watch",
-    "watch": "npm run watch:ts",
+    "check": "tsc --noEmit",
     "test:ts": "mocha --config test/mocharc.custom.json src/**/*.test.ts",
     "test:package": "mocha test/package --exit",
-    "test:unit": "mocha test/unit --exit",
     "test:integration": "mocha test/integration --exit",
     "test": "npm run test:ts && npm run test:package",
-    "check": "tsc --noEmit",
-    "lint": "eslint --ext .ts src/",
+    "lint": "eslint -c eslint.config.mjs .",
     "translate": "translate-adapter",
     "release": "release-script"
   },

package/src/controls/AalEmergency.ts

@@ -0,0 +1,90 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for AalEmergency controls.
+ */
+export class AalEmergency extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'alarm',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'status',
+            'disableEndTime',
+            'resetActive',
+        ]);
+
+        const statusStates = {
+            0: 'Running',
+            1: 'Triggered',
+            2: 'Reset',
+            3: 'Disabled',
+        };
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'status',
+            'number',
+            'value',
+            { states: statusStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'disableEndTime',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'resetActive',
+            'string',
+            'text',
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'trigger');
+        this.addStateChangeListener(
+            `${uuid}.trigger`,
+            () => {
+                this.sendCommand(control.uuidAction, 'trigger');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'quit');
+        this.addStateChangeListener(
+            `${uuid}.quit`,
+            () => {
+                this.sendCommand(control.uuidAction, 'quit');
+            },
+            { selfAck: true },
+        );
+
+        await this.createNumberInputStateObjectAsync(control.name, uuid, 'disable', 'level.timer');
+        this.addStateChangeListener(`${uuid}.disable`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `disable/${newValue || '0'}`);
+        });
+
+        await this.loadSubControlsAsync(uuid, control);
+    }
+}

package/src/controls/AalSmartAlarm.ts

@@ -0,0 +1,99 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for AAL Smart Alarm controls.
+ */
+export class AalSmartAlarm extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'alarm',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'alarmLevel',
+            'alarmCause',
+            'isLocked',
+            'isLeaveActive',
+            'disableEndTime',
+        ]);
+
+        const levelStates = {
+            0: 'None',
+            1: 'Immediate',
+            2: 'Delayed',
+        };
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'alarmLevel',
+            'number',
+            'value',
+            { states: levelStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'alarmCause',
+            'string',
+            'text',
+        );
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'isLocked', 'indicator');
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'isLeaveActive',
+            'indicator',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'disableEndTime',
+            'number',
+            'value.interval',
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'confirm');
+        this.addStateChangeListener(
+            `${uuid}.confirm`,
+            () => {
+                this.sendCommand(control.uuidAction, 'confirm');
+            },
+            { selfAck: true },
+        );
+
+        await this.createNumberInputStateObjectAsync(control.name, uuid, 'disable', 'level.timer');
+        this.addStateChangeListener(`${uuid}.disable`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `disable/${newValue || '0'}`);
+        });
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'startDrill');
+        this.addStateChangeListener(
+            `${uuid}.startDrill`,
+            () => {
+                this.sendCommand(control.uuidAction, 'startDrill');
+            },
+            { selfAck: true },
+        );
+
+        await this.loadSubControlsAsync(uuid, control);
+    }
+}

package/src/controls/Alarm.ts

@@ -0,0 +1,146 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Alarm controls.
+ */
+export class Alarm extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'alarm',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'armed',
+            'nextLevel',
+            'nextLevelDelay',
+            'nextLevelDelayTotal',
+            'level',
+            'startTime',
+            'armedDelay',
+            'armedDelayTotal',
+            'sensors',
+            'disabledMove',
+        ]);
+
+        const levelStates = {
+            0: 'None',
+            1: 'Silent',
+            2: 'Acustic',
+            3: 'Optical',
+            4: 'Internal',
+            5: 'External',
+            6: 'Remote',
+        };
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'armed', 'switch', {
+            write: true,
+            // TODO: re-add: smartIgnore: false,
+        });
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'nextLevel',
+            'number',
+            'value',
+            { states: levelStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'nextLevelDelay',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'nextLevelDelayTotal',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'level', 'number', 'value', {
+            states: levelStates,
+        });
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'startTime',
+            'string',
+            'value.datetime',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'armedDelay',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'armedDelayTotal',
+            'number',
+            'value.interval',
+        );
+        await this.createListControlStateObjectAsync(control.name, uuid, control.states, 'sensors');
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'disabledMove', 'switch', {
+            write: true,
+        });
+
+        this.addStateChangeListener(`${uuid}.armed`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            if (newValue) {
+                this.sendCommand(control.uuidAction, 'on');
+            } else {
+                this.sendCommand(control.uuidAction, 'off');
+            }
+        });
+
+        this.addStateChangeListener(`${uuid}.disabledMove`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            if (newValue) {
+                this.sendCommand(control.uuidAction, 'dismv/0');
+            } else {
+                this.sendCommand(control.uuidAction, 'dismv/1');
+            }
+        });
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'delayedOn');
+        this.addStateChangeListener(
+            `${uuid}.delayedOn`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                this.sendCommand(control.uuidAction, `delayedon/${newValue ? 1 : 0}`);
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'quit');
+        this.addStateChangeListener(
+            `${uuid}.quit`,
+            () => {
+                this.sendCommand(control.uuidAction, 'quit');
+            },
+            { selfAck: true },
+        );
+
+        // subControls are not needed because "sensors" already contains the information from the tracker
+    }
+}

package/src/controls/AlarmClock.ts

@@ -0,0 +1,137 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Alarm Clock controls.
+ */
+export class AlarmClock extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'alarm', // TODO: what's the best role here? ioBroker doc is not very clear on what's an "alarm"
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'isEnabled',
+            'isAlarmActive',
+            'confirmationNeeded',
+            'ringingTime',
+            'ringDuration',
+            'prepareDuration',
+            'snoozeTime',
+            'snoozeDuration',
+        ]);
+
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'isEnabled', 'switch', {
+            write: true,
+            // TODO: re-add: smartIgnore: false,
+        });
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'isAlarmActive',
+            'indicator',
+        );
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'confirmationNeeded',
+            'indicator',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'ringingTime',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'ringDuration',
+            'number',
+            'value.interval',
+            { write: true },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'prepareDuration',
+            'number',
+            'value.interval',
+            { write: true },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'snoozeTime',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'snoozeDuration',
+            'number',
+            'value.interval',
+            { write: true },
+        );
+
+        this.addStateChangeListener(`${uuid}.isEnabled`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `setActive/${newValue ? '0' : '1'}`); // yes, really, this is inverted!
+        });
+        this.addStateChangeListener(`${uuid}.ringDuration`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, `setRingDuration/${newValue}`);
+        });
+        this.addStateChangeListener(
+            `${uuid}.prepareDuration`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                this.sendCommand(control.uuidAction, `setPrepDuration/${newValue}`);
+            },
+        );
+        this.addStateChangeListener(
+            `${uuid}.snoozeDuration`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                this.sendCommand(control.uuidAction, `setSnoozeDuration/${newValue}`);
+            },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'snooze');
+        this.addStateChangeListener(
+            `${uuid}.snooze`,
+            () => {
+                this.sendCommand(control.uuidAction, 'snooze');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'dismiss');
+        this.addStateChangeListener(
+            `${uuid}.dismiss`,
+            () => {
+                this.sendCommand(control.uuidAction, 'dismiss');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/Application.ts

@@ -0,0 +1,13 @@
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Application controls.
+ */
+export class Application extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     */
+    async loadAsync(): Promise<void> {
+        // Application has no states, thus we don't use it at all
+    }
+}