iobroker.loxone 3.0.1 → 4.0.1

package/src/controls/LightControllerV2.ts

@@ -0,0 +1,246 @@
+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 LightControllerV2 controls.
+ */
+export class LightControllerV2 extends ControlBase {
+    private activeMoods: string[] = [];
+    private favoriteMoods: string[] = [];
+    private additionalMoods: string[] = [];
+
+    private idToMoodName: Record<string, string> = {};
+    private moodNameToId: Record<string, string> = {};
+
+    private uuid = '';
+
+    /**
+     * 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> {
+        this.uuid = uuid;
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'light',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'activeMoods',
+            'moodList',
+            'favoriteMoods',
+            'additionalMoods',
+        ]);
+
+        if (
+            'activeMoods' in control.states &&
+            'moodList' in control.states &&
+            'favoriteMoods' in control.states &&
+            'additionalMoods' in control.states
+        ) {
+            await this.updateStateObjectAsync(
+                `${uuid}.moodList`,
+                {
+                    name: `${control.name}: moodList`,
+                    read: true,
+                    write: false,
+                    type: 'array',
+                    role: 'list',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.moodList,
+                async (name: string, value: any) => {
+                    const moodList = JSON.parse(value);
+                    const list = [];
+                    this.idToMoodName = {};
+                    this.moodNameToId = {};
+                    for (const index in moodList) {
+                        const mood = moodList[index];
+                        if ('id' in mood && 'name' in mood) {
+                            this.idToMoodName[mood.id] = mood.name;
+                            this.moodNameToId[mood.name] = mood.id;
+                            list.push(mood.name);
+                        }
+                    }
+                    await this.updateActiveMoods();
+                    await this.updateFavoriteMoods();
+                    await this.updateAdditionalMoods();
+
+                    await this.setStateAck(name, JSON.stringify(list));
+                },
+            );
+            await this.updateStateObjectAsync(
+                `${uuid}.activeMoods`,
+                {
+                    name: `${control.name}: activeMoods`,
+                    read: true,
+                    write: true,
+                    type: 'array',
+                    role: 'list',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.activeMoods,
+                async (name: string, value: any) => {
+                    this.activeMoods = JSON.parse(value);
+                    await this.updateActiveMoods();
+                },
+            );
+            this.addStateChangeListener(
+                `${uuid}.activeMoods`,
+                (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                    let arrayValue: string[];
+                    if (Array.isArray(newValue)) {
+                        arrayValue = newValue;
+                    } else {
+                        try {
+                            newValue = JSON.parse(newValue as string);
+                        } catch {
+                            // ignore error, continue below
+                        }
+                        if (!Array.isArray(newValue)) {
+                            arrayValue = (newValue as string).split(',');
+                        } else {
+                            arrayValue = newValue;
+                        }
+                    }
+
+                    const ids = [];
+                    for (let i = 0; i < arrayValue.length; i++) {
+                        const moodName = arrayValue[i];
+                        if (!(moodName in this.moodNameToId)) {
+                            this.adapter.log.warn(`Can't find mood name '${moodName}', discarding new value`);
+                            return;
+                        }
+                        ids.push(this.moodNameToId[moodName]);
+                    }
+                    if (ids.length === 0) {
+                        this.adapter.log.warn(`${uuid}.activeMoods can't have zero IDs, discarding new value`);
+                        return;
+                    }
+
+                    const addMoods = [];
+                    const removeMoods = [];
+                    let hasKeepMoods = false;
+                    for (let i = 0; i < ids.length; i++) {
+                        if (this.activeMoods.includes(ids[i])) {
+                            hasKeepMoods = true;
+                        } else {
+                            addMoods.push(ids[i]);
+                        }
+                    }
+                    for (let i = 0; i < this.activeMoods.length; i++) {
+                        if (!ids.includes(this.activeMoods[i])) {
+                            removeMoods.push(this.activeMoods[i]);
+                        }
+                    }
+                    if (hasKeepMoods) {
+                        for (let i = 0; i < removeMoods.length; i++) {
+                            this.sendCommand(control.uuidAction, `removeMood/${removeMoods[i]}`);
+                        }
+                    } else {
+                        const firstId = addMoods.shift();
+                        this.sendCommand(control.uuidAction, `changeTo/${firstId}`);
+                    }
+
+                    for (let i = 0; i < addMoods.length; i++) {
+                        this.sendCommand(control.uuidAction, `addMood/${addMoods[i]}`);
+                    }
+                },
+            );
+            await this.updateStateObjectAsync(
+                `${uuid}.favoriteMoods`,
+                {
+                    name: `${control.name}: favoriteMoods`,
+                    read: true,
+                    write: false,
+                    type: 'array',
+                    role: 'list',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.favoriteMoods,
+                async (id: string, value: any) => {
+                    this.favoriteMoods = JSON.parse(value);
+                    await this.updateFavoriteMoods();
+                },
+            );
+            await this.updateStateObjectAsync(
+                `${uuid}.additionalMoods`,
+                {
+                    name: `${control.name}: additionalMoods`,
+                    read: true,
+                    write: false,
+                    type: 'array',
+                    role: 'list',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.additionalMoods,
+                async (name: string, value: any) => {
+                    this.additionalMoods = JSON.parse(value);
+                    await this.updateAdditionalMoods();
+                },
+            );
+        }
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'plus');
+        this.addStateChangeListener(
+            `${uuid}.plus`,
+            () => {
+                this.sendCommand(control.uuidAction, 'plus');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'minus');
+        this.addStateChangeListener(
+            `${uuid}.minus`,
+            () => {
+                this.sendCommand(control.uuidAction, 'minus');
+            },
+            { selfAck: true },
+        );
+
+        // TODO: add Alexa support! (how???)
+
+        // TODO: currently we don't support scene modifications ("learn" and "delete" commands),
+        // IMHO this should be done by the user through the Loxone Web interface
+
+        await this.loadSubControlsAsync(uuid, control);
+    }
+
+    private async updateMoodsList(name: string, idList: string[]): Promise<void> {
+        if (Object.keys(this.idToMoodName).length === 0) {
+            return;
+        }
+        const list = [];
+        for (const id of idList) {
+            if (id in this.idToMoodName) {
+                list.push(this.idToMoodName[id]);
+            } else {
+                list.push(id);
+            }
+        }
+
+        await this.setStateAck(`${this.uuid}.${name}`, JSON.stringify(list));
+    }
+
+    private async updateActiveMoods(): Promise<void> {
+        await this.updateMoodsList('activeMoods', this.activeMoods);
+    }
+
+    private async updateFavoriteMoods(): Promise<void> {
+        await this.updateMoodsList('favoriteMoods', this.favoriteMoods);
+    }
+
+    private async updateAdditionalMoods(): Promise<void> {
+        await this.updateMoodsList('additionalMoods', this.additionalMoods);
+    }
+}

package/src/controls/MailBox.ts

@@ -0,0 +1,92 @@
+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 MailBox controls.
+ */
+export class MailBox 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, [
+            'notificationsDisabledInput',
+            'packetReceived',
+            'mailReceived',
+            'disableEndTime',
+        ]);
+
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'notificationsDisabledInput',
+            'indicator',
+        );
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'packetReceived',
+            'indicator',
+        );
+        await this.createBooleanControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'mailReceived',
+            'indicator',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'disableEndTime',
+            'number',
+            'value.interval',
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'confirmPacket');
+        this.addStateChangeListener(
+            `${uuid}.confirmPacket`,
+            () => {
+                this.sendCommand(control.uuidAction, 'confirmPacket');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'confirmMail');
+        this.addStateChangeListener(
+            `${uuid}.confirmMail`,
+            () => {
+                this.sendCommand(control.uuidAction, 'confirmMail');
+            },
+            { selfAck: true },
+        );
+
+        await this.createNumberInputStateObjectAsync(control.name, uuid, 'disableNotifications', 'level.timer');
+        this.addStateChangeListener(
+            `${uuid}.disableNotifications`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                this.sendCommand(control.uuidAction, `disableNotifications/${newValue || '0'}`);
+            },
+        );
+
+        await this.loadSubControlsAsync(uuid, control);
+    }
+}

package/src/controls/Meter.ts

@@ -0,0 +1,94 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Meter controls.
+ */
+export class Meter 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, ['actual', 'total']);
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'actual',
+            'number',
+            'value.power.consumption',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'total',
+            'number',
+            'value.power.consumption',
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'reset');
+        this.addStateChangeListener(
+            `${uuid}.reset`,
+            () => {
+                this.sendCommand(control.uuidAction, 'reset');
+            },
+            { selfAck: true },
+        );
+
+        if (!('details' in control)) {
+            return;
+        }
+
+        if ('actualFormat' in control.details) {
+            await this.updateStateObjectAsync(
+                `${uuid}.actual-formatted`,
+                {
+                    name: `${control.name}: formatted actual value`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.actual,
+                async (name: string, value: any) => {
+                    await this.setFormattedStateAck(name, value, control.details.actualFormat as string);
+                },
+            );
+        }
+
+        if ('totalFormat' in control.details) {
+            await this.updateStateObjectAsync(
+                `${uuid}.total-formatted`,
+                {
+                    name: `${control.name}: formatted total value`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                control.states.total,
+                async (name: string, value: any) => {
+                    await this.setFormattedStateAck(name, value, control.details.totalFormat as string);
+                },
+            );
+        }
+    }
+}

package/src/controls/None.ts

@@ -0,0 +1,29 @@
+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 no type (currently seems to be only for window monitoring).
+ * It will just load the simple default states.
+ */
+export class None 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, []);
+    }
+}

package/src/controls/PresenceDetector.ts

@@ -0,0 +1,47 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for PresenceDetector controls.
+ */
+export class PresenceDetector 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',
+            'locked',
+            'events',
+            'infoText',
+        ]);
+
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'active', 'indicator');
+        await this.createBooleanControlStateObjectAsync(control.name, uuid, control.states, 'locked', 'indicator');
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'events', 'number', 'value');
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'infoText',
+            'string',
+            'text',
+        );
+
+        await this.loadSubControlsAsync(uuid, control);
+    }
+}

package/src/controls/Pushbutton.ts

@@ -0,0 +1,55 @@
+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 Pushbutton controls.
+ */
+export class Pushbutton 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 },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'pulse');
+        this.addStateChangeListener(
+            `${uuid}.pulse`,
+            () => {
+                this.sendCommand(control.uuidAction, 'pulse');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/Radio.ts

@@ -0,0 +1,61 @@
+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 Radio controls.
+ */
+export class Radio 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: 'button',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['activeOutput']);
+
+        let states: Record<string, string> = {};
+        if ('allOff' in control.details) {
+            states['0'] = control.details.allOff as string;
+        }
+        if ('outputs' in control.details) {
+            states = { ...states, ...(control.details.outputs as Record<string, string>) };
+        }
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'activeOutput',
+            'number',
+            'level',
+            {
+                states,
+                write: true,
+            },
+        );
+        this.addStateChangeListener(
+            `${uuid}.activeOutput`,
+            (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+                const value = this.convertStateToInt(newValue);
+                if (value === 0) {
+                    this.sendCommand(control.uuidAction, 'reset');
+                } else if (value in states) {
+                    this.sendCommand(control.uuidAction, value.toString());
+                }
+            },
+            { notIfEqual: true },
+        );
+    }
+}

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

@@ -1,13 +1,22 @@
 'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Remote = void 0;
-const control_base_1 = require("./control-base");
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
 /**
  * Remote aka. Media Controller
  */
-class Remote extends control_base_1.ControlBase {
-    async loadAsync(type, uuid, control) {
-        this.adapter.log.debug('Remote controls: ' + JSON.stringify(control));
+export class Remote 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> {
+        this.adapter.log.debug(`Remote controls: ${JSON.stringify(control)}`);
         await this.updateObjectAsync(uuid, {
             type: type,
             common: {
@@ -16,21 +25,20 @@ class Remote extends control_base_1.ControlBase {
             },
             native: { control },
         });
+
         await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['jLocked', 'mode']);
+
         await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'mode', 'string', 'text', {
             write: true,
         });
-        this.addStateChangeListener(uuid + '.mode', (oldValue, newValue) => {
+        this.addStateChangeListener(`${uuid}.mode`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
             if (newValue && newValue !== '0') {
                 // Send the actual mode number
                 this.sendCommand(control.uuidAction, `mode/${newValue}`);
-            }
-            else {
+            } else {
                 // Sending mode zero is not supported so sent reset/all off
                 this.sendCommand(control.uuidAction, 'reset');
             }
         });
     }
 }
-exports.Remote = Remote;
-//# sourceMappingURL=Remote.js.map