iobroker.loxone 3.0.1 → 4.0.0

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
+    }
+}