iobroker.loxone 3.0.0 → 4.0.0

package/src/controls/Slider.ts

@@ -0,0 +1,78 @@
+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 Slider controls.
+ */
+export class Slider 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: 'sensor',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['value', 'error']);
+
+        const common: Partial<ioBroker.StateCommon> = { write: true };
+        if ('details' in control) {
+            common.min = control.details.min as number;
+            common.max = control.details.max as number;
+        }
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'value',
+            'number',
+            'level',
+            common,
+        );
+        this.addStateChangeListener(`${uuid}.value`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, (newValue || '0').toString());
+        });
+
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'error',
+            'indicator.maintenance',
+        );
+
+        if (!('details' in control)) {
+            return;
+        }
+
+        if ('format' in control.details) {
+            await this.updateStateObjectAsync(
+                `${uuid}.value-formatted`,
+                {
+                    name: `${control.name}: formatted value`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.value,
+                async (name: string, value: any) => {
+                    await this.setFormattedStateAck(name, value, control.details.format as string);
+                },
+            );
+        }
+    }
+}

package/src/controls/SmokeAlarm.ts

@@ -0,0 +1,163 @@
+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 SmokeAlarm controls.
+ */
+export class SmokeAlarm 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, [
+            'nextLevel',
+            'nextLevelDelay',
+            'nextLevelDelayTotal',
+            'level',
+            'sensors',
+            'acousticAlarm',
+            'testAlarm',
+            'alarmCause',
+            'startTime',
+            'timeServiceMode',
+        ]);
+
+        const levelStates = {
+            0: 'None',
+            1: 'Silent',
+            2: 'Acustic',
+            3: 'Optical',
+            4: 'Internal',
+            5: 'External',
+            6: 'Remote',
+        };
+        const causeStates = {
+            0: 'None',
+            1: 'Smoke',
+            2: 'Water',
+            3: 'Smoke & Water',
+            4: 'Temperature',
+            5: 'Temperature & Smoke',
+            6: 'Temperature & Water',
+            7: 'Temperature & Smoke & Water',
+            8: 'Arc Fault',
+            9: 'Arc Fault & Smoke',
+            10: 'Arc Fault & Water',
+            11: 'Arc Fault & Smoke & Water',
+            12: 'Arc Fault & Temperature',
+            13: 'Arc Fault & Temperature & Smoke',
+            14: 'Arc Fault & Temperature & Water',
+            15: 'Arc Fault & Temperature & Smoke & Water',
+        };
+        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.createListControlStateObjectAsync(control.name, uuid, control.states, 'sensors');
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'acousticAlarm',
+            'indicator',
+        );
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'testAlarm', 'indicator');
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'alarmCause',
+            'number',
+            'value',
+            { states: causeStates },
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'startTime',
+            'string',
+            'value.datetime',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'timeServiceMode',
+            'number',
+            'level.interval',
+            { write: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'mute');
+        this.addStateChangeListener(
+            `${uuid}.mute`,
+            () => {
+                this.sendCommand(control.uuidAction, 'mute');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'quit');
+        this.addStateChangeListener(
+            `${uuid}.quit`,
+            () => {
+                this.sendCommand(control.uuidAction, 'quit');
+            },
+            { selfAck: true },
+        );
+
+        this.addStateChangeListener(
+            `${uuid}.timeServiceMode`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                newValue = this.convertStateToInt(newValue);
+                if (newValue === undefined || newValue < 0) {
+                    return;
+                }
+
+                this.sendCommand(control.uuidAction, `servicemode/${newValue}`);
+            },
+        );
+
+        // subControls are not needed because "sensors" already contains the information from the tracker
+    }
+}

package/src/controls/Switch.ts

@@ -0,0 +1,46 @@
+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 Switch controls.
+ */
+export class Switch 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: 'switch',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['active']);
+
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'active', 'switch', {
+            write: true,
+            // TODO: re-add: smartIgnore: type == 'channel',
+        });
+
+        this.addStateChangeListener(
+            `${uuid}.active`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                if (newValue) {
+                    this.sendCommand(control.uuidAction, 'on');
+                } else {
+                    this.sendCommand(control.uuidAction, 'off');
+                }
+            },
+            { notIfEqual: true },
+        );
+    }
+}

package/src/controls/SystemScheme.ts

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

package/src/controls/TextInput.ts

@@ -0,0 +1,96 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control, ControlStates } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for TextInput controls.
+ */
+export class TextInput 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: 'sensor',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['text']);
+
+        const common: Partial<ioBroker.StateCommon> = { write: true };
+
+        await this.createTextInputStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'text',
+            'string',
+            'text',
+            common,
+        );
+        this.addStateChangeListener(`${uuid}.text`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, (newValue || '').toString());
+        });
+
+        if (!('details' in control)) {
+            return;
+        }
+
+        if ('format' in control.details) {
+            await this.updateStateObjectAsync(
+                `${uuid}.value-formatted`,
+                {
+                    name: `${control.name}: formatted value`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.value,
+                async (name: string, value: any) => {
+                    await this.setFormattedStateAck(name, value, control.details.format as string);
+                },
+            );
+        }
+    }
+
+    protected async createTextInputStateObjectAsync(
+        controlName: string,
+        uuid: string,
+        states: ControlStates,
+        name: string,
+        type: ioBroker.CommonType,
+        role: string,
+        commonExt?: Partial<ioBroker.StateCommon>,
+    ): Promise<void> {
+        if (states !== undefined && name in states) {
+            let common: ioBroker.StateCommon = {
+                name: `${controlName}: ${name}`,
+                read: false,
+                write: true,
+                type: type,
+                role: role,
+                //smartIgnore: true,
+            };
+            if (commonExt && typeof commonExt === 'object') {
+                common = { ...common, ...commonExt };
+            }
+            await this.updateStateObjectAsync(
+                `${uuid}.${this.normalizeName(name)}`,
+                common,
+                states[name],
+                this.setStateAck.bind(this),
+            );
+        }
+    }
+}

package/src/controls/TextState.ts

@@ -0,0 +1,37 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for TextState controls.
+ */
+export class TextState 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: 'info',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['textAndIcon']);
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'textAndIcon',
+            'string',
+            'text',
+        );
+    }
+}

package/src/controls/TimedSwitch.ts

@@ -0,0 +1,75 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for TimedSwitch controls.
+ */
+export class TimedSwitch 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: 'switch',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'deactivationDelayTotal',
+            'deactivationDelay',
+        ]);
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'deactivationDelayTotal',
+            'number',
+            'value.interval',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'deactivationDelay',
+            'number',
+            'value.interval',
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'on');
+        this.addStateChangeListener(
+            `${uuid}.on`,
+            () => {
+                this.sendCommand(control.uuidAction, 'on');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'off');
+        this.addStateChangeListener(
+            `${uuid}.off`,
+            () => {
+                this.sendCommand(control.uuidAction, 'off');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'pulse');
+        this.addStateChangeListener(
+            `${uuid}.pulse`,
+            () => {
+                this.sendCommand(control.uuidAction, 'pulse');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/Tracker.ts

@@ -0,0 +1,30 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Tracker controls.
+ */
+export class Tracker 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: 'info',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['entries']);
+
+        await this.createListControlStateObjectAsync(control.name, uuid, control.states, 'entries');
+    }
+}

package/{build/controls/Unknown.js → src/controls/Unknown.ts}

@@ -1,31 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Unknown = void 0;
-const SentryNode = require("@sentry/node");
-const control_base_1 = require("./control-base");
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
 /**
  * This class is used if the control has an unknown type.
  * It will just load the simple default states.
  */
-class Unknown extends control_base_1.ControlBase {
-    async loadAsync(type, uuid, control) {
-        var _a;
+export class Unknown 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> {
         // report unsupported control
         const existingObject = this.adapter.getExistingObject(uuid);
         const currentVersion = this.adapter.version;
         const msg = `Unsupported ${type} control ${control.type}`;
         this.adapter.log.info(msg);
-        if (((_a = existingObject === null || existingObject === void 0 ? void 0 : existingObject.native) === null || _a === void 0 ? void 0 : _a.reportedVersion) !== currentVersion) {
+        if (existingObject?.native?.reportedVersion !== currentVersion) {
             // missing control wasn't reported yet for the current adapter version
             if (!this.adapter.reportedMissingControls.has(msg)) {
                 this.adapter.reportedMissingControls.add(msg);
                 const sentry = this.adapter.getSentry();
-                sentry === null || sentry === void 0 ? void 0 : sentry.withScope((scope) => {
+                sentry?.withScope(scope => {
                     scope.setExtra('control', JSON.stringify(control, null, 2));
-                    sentry.captureMessage(msg, SentryNode.Severity.Warning);
+                    sentry.captureMessage(msg, 'warning');
                 });
             }
         }
+
         await this.updateObjectAsync(uuid, {
             type: type,
             common: {
@@ -34,9 +40,9 @@ class Unknown extends control_base_1.ControlBase {
             },
             native: { control, reportedVersion: currentVersion },
         });
+
         await this.loadOtherControlStatesAsync(control.name, uuid, control.states, []);
+
         await this.loadSubControlsAsync(uuid, control);
     }
 }
-exports.Unknown = Unknown;
-//# sourceMappingURL=Unknown.js.map

package/src/controls/UpDownAnalog.ts

@@ -0,0 +1,78 @@
+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 UpDownAnalog controls.
+ */
+export class UpDownAnalog 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: 'sensor',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['value', 'error']);
+
+        const common: Partial<ioBroker.StateCommon> = { write: true };
+        if ('details' in control) {
+            common.min = control.details.min as number;
+            common.max = control.details.max as number;
+        }
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'value',
+            'number',
+            'level',
+            common,
+        );
+        this.addStateChangeListener(`${uuid}.value`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, (newValue || '0').toString());
+        });
+
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'error',
+            'indicator.maintenance',
+        );
+
+        if (!('details' in control)) {
+            return;
+        }
+
+        if ('format' in control.details) {
+            await this.updateStateObjectAsync(
+                `${uuid}.value-formatted`,
+                {
+                    name: `${control.name}: formatted value`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.value,
+                async (name: string, value: any) => {
+                    await this.setFormattedStateAck(name, value, control.details.format as string);
+                },
+            );
+        }
+    }
+}