iobroker.loxone 3.0.1 → 4.0.1

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

@@ -1,9 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueSelector = void 0;
-const control_base_1 = require("./control-base");
-class ValueSelector extends control_base_1.ControlBase {
-    async loadAsync(type, uuid, control) {
+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 ValueSelector controls.
+ */
+export class ValueSelector 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: {
@@ -12,17 +23,18 @@ class ValueSelector extends control_base_1.ControlBase {
             },
             native: { control },
         });
+
         await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['value', 'min', 'max', 'step']);
+
         await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'value', 'number', 'level', {
             write: true,
         });
         await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'min', 'number', 'value');
         await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'max', 'number', 'value');
         await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'step', 'number', 'value');
-        this.addStateChangeListener(uuid + '.value', (oldValue, newValue) => {
+
+        this.addStateChangeListener(`${uuid}.value`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
             this.sendCommand(control.uuidAction, this.convertStateToInt(newValue).toString());
         });
     }
 }
-exports.ValueSelector = ValueSelector;
-//# sourceMappingURL=ValueSelector.js.map

package/src/controls/WindowMonitor.ts

@@ -0,0 +1,139 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for WindowMonitor controls.
+ */
+export class WindowMonitor 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, [
+            'windowStates',
+            'numOpen',
+            'numClosed',
+            'numTilted',
+            'numOffline',
+            'numLocked',
+            'numUnlocked',
+        ]);
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'numOpen',
+            'number',
+            'value',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'numClosed',
+            'number',
+            'value',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'numTilted',
+            'number',
+            'value',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'numOffline',
+            'number',
+            'value',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'numLocked',
+            'number',
+            'value',
+        );
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'numUnlocked',
+            'number',
+            'value',
+        );
+
+        if (!('details' in control) || !('windows' in control.details) || !('windowStates' in control.states)) {
+            return;
+        }
+        const windowPositions: Record<number, string> = {
+            1: 'closed',
+            2: 'tilted',
+            4: 'open',
+            8: 'locked',
+            16: 'unlocked',
+        };
+        const windows = control.details.windows as any;
+        for (const index in windows) {
+            const window = windows[index];
+            const id = `${uuid}.${parseInt(index) + 1}`;
+            await this.updateObjectAsync(id, {
+                type: 'channel',
+                common: {
+                    name: `${control.name}: ${window.name}`,
+                    role: 'sensor.window.3',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                native: window,
+            });
+            for (let mask = 1; mask <= 16; mask *= 2) {
+                const windowPosition = windowPositions[mask];
+                const obj: ioBroker.SettableObject = {
+                    type: 'state',
+                    common: {
+                        name: `${control.name}: ${window.name}: ${windowPosition}`,
+                        read: true,
+                        write: false,
+                        type: 'boolean',
+                        role: 'indicator',
+                        // TODO: re-add: smartIgnore: true,
+                    },
+                    native: {},
+                };
+                await this.updateObjectAsync(`${id}.${windowPosition}`, obj);
+            }
+        }
+
+        this.addStateEventHandler(control.states.windowStates, async (value: any) => {
+            const values = value.toString().split(',');
+            for (const index in values) {
+                for (let mask = 1; mask <= 16; mask *= 2) {
+                    const windowPosition = windowPositions[mask];
+                    await this.setStateAck(
+                        `${uuid}.${parseInt(index) + 1}.${windowPosition}`,
+                        (parseInt(values[index]) & mask) == mask,
+                    );
+                }
+            }
+        });
+    }
+}

package/src/controls/all-controls.ts

@@ -0,0 +1,99 @@
+import { AalEmergency } from './AalEmergency';
+import { AalSmartAlarm } from './AalSmartAlarm';
+import { Alarm } from './Alarm';
+import { AlarmClock } from './AlarmClock';
+import { Application } from './Application';
+import { AudioZone } from './AudioZone';
+import { AudioZoneV2 } from './AudioZoneV2';
+import { CentralAlarm } from './CentralAlarm';
+import { CentralAudioZone } from './CentralAudioZone';
+import { CentralGate } from './CentralGate';
+import { CentralJalousie } from './CentralJalousie';
+import { CentralLightController } from './CentralLightController';
+import { Colorpicker } from './Colorpicker';
+import { ColorPickerV2 } from './ColorPickerV2';
+import { Daytimer } from './Daytimer';
+import { Dimmer } from './Dimmer';
+import { EIBDimmer } from './EIBDimmer';
+import { Fronius } from './Fronius';
+import { Gate } from './Gate';
+import { Hourcounter } from './Hourcounter';
+import { InfoOnlyAnalog } from './InfoOnlyAnalog';
+import { InfoOnlyDigital } from './InfoOnlyDigital';
+import { InfoOnlyText } from './InfoOnlyText';
+import { Intercom } from './Intercom';
+import { IRCDaytimer } from './IRCDaytimer';
+import { IRCV2Daytimer } from './IRCV2Daytimer';
+import { IRoomControllerV2 } from './IRoomControllerV2';
+import { Jalousie } from './Jalousie';
+import { LightController } from './LightController';
+import { LightControllerV2 } from './LightControllerV2';
+import { MailBox } from './MailBox';
+import { Meter } from './Meter';
+import { PresenceDetector } from './PresenceDetector';
+import { Pushbutton } from './Pushbutton';
+import { Radio } from './Radio';
+import { Remote } from './Remote';
+import { Slider } from './Slider';
+import { SmokeAlarm } from './SmokeAlarm';
+import { Switch } from './Switch';
+import { SystemScheme } from './SystemScheme';
+import { TextInput } from './TextInput';
+import { TextState } from './TextState';
+import { TimedSwitch } from './TimedSwitch';
+import { Tracker } from './Tracker';
+import { Unknown } from './Unknown';
+import { UpDownAnalog } from './UpDownAnalog';
+import { ValueSelector } from './ValueSelector';
+import { WindowMonitor } from './WindowMonitor';
+
+export const AllControls = {
+    AalEmergency,
+    AalSmartAlarm,
+    AlarmClock,
+    Alarm,
+    Application,
+    AudioZone,
+    AudioZoneV2,
+    CentralAlarm,
+    CentralAudioZone,
+    CentralGate,
+    CentralJalousie,
+    CentralLightController,
+    Colorpicker,
+    ColorPickerV2,
+    Daytimer,
+    Dimmer,
+    EIBDimmer,
+    Fronius,
+    Gate,
+    Hourcounter,
+    InfoOnlyAnalog,
+    InfoOnlyDigital,
+    InfoOnlyText,
+    Intercom,
+    IRCDaytimer,
+    IRCV2Daytimer,
+    IRoomControllerV2,
+    Jalousie,
+    LightController,
+    LightControllerV2,
+    MailBox,
+    Meter,
+    PresenceDetector,
+    Pushbutton,
+    Radio,
+    Remote,
+    Slider,
+    SmokeAlarm,
+    Switch,
+    SystemScheme,
+    TextInput,
+    TextState,
+    TimedSwitch,
+    Tracker,
+    Unknown,
+    UpDownAnalog,
+    ValueSelector,
+    WindowMonitor,
+} as const;

package/src/controls/control-base.ts

@@ -0,0 +1,28 @@
+import { LoxoneHandlerBase } from '../loxone-handler-base';
+import type { Loxone } from '../main';
+import type { Control } from '../structure-file';
+
+export type ControlType = 'device' | 'channel';
+
+/**
+ * Base class for all control handlers.
+ */
+export abstract class ControlBase extends LoxoneHandlerBase {
+    /**
+     * Creates an instance of this class.
+     *
+     * @param adapter The Loxone adapter instance.
+     */
+    constructor(protected readonly adapter: Loxone) {
+        super(adapter);
+    }
+
+    /**
+     * 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.
+     */
+    abstract loadAsync(type: ControlType, uuid: string, control: Control): Promise<void>;
+}

package/src/lib/adapter-config.d.ts

@@ -0,0 +1,22 @@
+// This file extends the AdapterConfig type from "@iobroker/types"
+
+// Augment the globally declared type ioBroker.AdapterConfig
+declare global {
+    namespace ioBroker {
+        interface AdapterConfig {
+            host: string;
+            port: number;
+            username: string;
+            password: string;
+            syncNames: boolean;
+            syncRooms: boolean;
+            syncFunctions: boolean;
+
+            /** if not set, it implies "all" */
+            weatherServer?: 'off' | 'current' | '1day' | 'all';
+        }
+    }
+}
+
+// this is required so the above AdapterConfig is found by TypeScript / type checking
+export {};

package/src/loxone-handler-base.ts

@@ -0,0 +1,285 @@
+import { sprintf } from 'sprintf-js';
+import type {
+    CurrentStateValue,
+    Loxone,
+    NamedStateEventHandler,
+    OldStateValue,
+    StateChangeListener,
+    StateChangeListenerOpts,
+    StateEventHandler,
+} from './main';
+import type { Control, ControlStates } from './structure-file';
+
+/**
+ * Base class for Loxone handlers.
+ */
+export abstract class LoxoneHandlerBase {
+    protected constructor(protected readonly adapter: Loxone) {}
+
+    protected async loadSubControlsAsync(parentUuid: string, control: Control): Promise<void> {
+        return await this.adapter.loadSubControlsAsync(parentUuid, control);
+    }
+
+    protected addStateChangeListener(id: string, listener: StateChangeListener, opts?: StateChangeListenerOpts): void {
+        this.adapter.addStateChangeListener(id, listener, opts);
+    }
+
+    protected addStateEventHandler(uuid: string, eventHandler: StateEventHandler, name?: string): void {
+        this.adapter.addStateEventHandler(uuid, eventHandler, name);
+    }
+
+    protected removeStateEventHandler(uuid: string, name: string): boolean {
+        return this.adapter.removeStateEventHandler(uuid, name);
+    }
+
+    protected sendCommand(uuid: string, action: string): void {
+        this.adapter.sendCommand(uuid, action);
+    }
+
+    protected async setStateAck(id: string, value: CurrentStateValue): Promise<void> {
+        await this.adapter.setStateAck(id, value);
+    }
+
+    protected async setFormattedStateAck(id: string, value: CurrentStateValue, format: string): Promise<void> {
+        value = sprintf(format, value);
+        await this.setStateAck(id, value);
+    }
+
+    protected convertStateToInt(value: OldStateValue): number {
+        return this.adapter.convertStateToInt(value);
+    }
+
+    protected convertStateToFloat(value: OldStateValue): number {
+        if (typeof value === 'number') {
+            return value;
+        }
+        return !value ? 0 : parseFloat(value.toString());
+    }
+
+    protected convertStateToBoolean(value: OldStateValue): boolean {
+        if (!value) {
+            return false;
+        }
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        value = value.toString();
+        return value !== '0' && value !== 'false';
+    }
+
+    protected getCachedStateValue(id: string): OldStateValue {
+        return this.adapter.getCachedStateValue(id);
+    }
+
+    protected async updateObjectAsync(id: string, obj: ioBroker.SettableObject): Promise<void> {
+        await this.adapter.updateObjectAsync(id, obj);
+    }
+
+    protected async updateStateObjectAsync(
+        id: string,
+        commonInfo: ioBroker.StateCommon,
+        stateUuid: string,
+        stateEventHandler?: NamedStateEventHandler,
+    ): Promise<void> {
+        await this.adapter.updateStateObjectAsync(id, commonInfo, stateUuid, stateEventHandler);
+    }
+
+    protected async loadOtherControlStatesAsync(
+        controlName: string,
+        uuid: string,
+        states: ControlStates,
+        skipKeys: string[],
+    ): Promise<void> {
+        if (states === undefined) {
+            return;
+        }
+
+        for (const stateName in states) {
+            if (skipKeys.indexOf(stateName) !== -1) {
+                continue;
+            }
+
+            await this.createSimpleControlStateObjectAsync(controlName, uuid, states, stateName, 'string', 'text', {
+                desc: 'This state is currently unsupported by this adapter, you can only see the text representation of it.',
+            });
+        }
+    }
+
+    protected async createSimpleControlStateObjectAsync(
+        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: true,
+                write: false,
+                type: type,
+                role: role,
+                // TODO: re-add: smartIgnore: true,
+            };
+            if (commonExt && typeof commonExt === 'object') {
+                common = { ...common, ...commonExt };
+            }
+            await this.updateStateObjectAsync(
+                `${uuid}.${this.normalizeName(name)}`,
+                common,
+                states[name],
+                (id, value) => {
+                    switch (type) {
+                        case 'number':
+                            value = this.convertStateToFloat(value);
+                            break;
+                        case 'boolean':
+                            value = this.convertStateToBoolean(value);
+                            break;
+                        default:
+                            value = value === null || value === undefined ? '' : value.toString();
+                            break;
+                    }
+                    return this.setStateAck(id, value);
+                },
+            );
+        }
+    }
+
+    protected async createBooleanControlStateObjectAsync(
+        controlName: string,
+        uuid: string,
+        states: ControlStates,
+        name: string,
+        role: string,
+        commonExt?: Partial<ioBroker.StateCommon>,
+        converter?: (value: CurrentStateValue) => boolean,
+    ): Promise<void> {
+        if (states !== undefined && name in states) {
+            let common: ioBroker.StateCommon = {
+                name: `${controlName}: ${name}`,
+                read: true,
+                write: false,
+                type: 'boolean' as ioBroker.CommonType,
+                role: role,
+                // TODO: re-add: smartIgnore: true,
+            };
+            if (commonExt && typeof commonExt === 'object') {
+                common = { ...common, ...commonExt };
+            }
+            const convert = converter || (value => value == 1);
+            await this.updateStateObjectAsync(
+                `${uuid}.${this.normalizeName(name)}`,
+                common,
+                states[name],
+                async (name: string, value: CurrentStateValue) => {
+                    await this.setStateAck(name, convert(value));
+                },
+            );
+        }
+    }
+
+    protected async createListControlStateObjectAsync(
+        controlName: string,
+        uuid: string,
+        states: ControlStates,
+        name: string,
+    ): Promise<void> {
+        if (states !== undefined && name in states) {
+            await this.updateStateObjectAsync(
+                `${uuid}.${this.normalizeName(name)}`,
+                {
+                    name: `${controlName}: ${name}`,
+                    read: true,
+                    write: false,
+                    type: 'array',
+                    role: 'list',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                states[name],
+                async (name: string, value: CurrentStateValue) => {
+                    await this.setStateAck(name, !value ? '[]' : JSON.stringify(value.toString().split('|')));
+                },
+            );
+        }
+    }
+
+    protected async createPercentageControlStateObjectAsync(
+        controlName: string,
+        uuid: string,
+        states: ControlStates,
+        name: string,
+        role: string,
+        commonExt?: Partial<ioBroker.StateCommon>,
+    ): Promise<void> {
+        if (states !== undefined && name in states) {
+            let common: ioBroker.StateCommon = {
+                name: `${controlName}: ${name}`,
+                read: true,
+                write: false,
+                type: 'number' as ioBroker.CommonType,
+                role: role,
+                unit: '%',
+                // TODO: re-add: smartIgnore: true,
+            };
+            if (commonExt && typeof commonExt === 'object') {
+                common = { ...common, ...commonExt };
+            }
+            await this.updateStateObjectAsync(
+                `${uuid}.${this.normalizeName(name)}`,
+                common,
+                states[name],
+                async (name: string, value: CurrentStateValue) => {
+                    await this.setStateAck(name, Math.round(this.convertStateToFloat(value) * 100));
+                },
+            );
+        }
+    }
+
+    protected async createButtonCommandStateObjectAsync(
+        controlName: string,
+        uuid: string,
+        name: string,
+        commonExt?: Partial<ioBroker.StateCommon>,
+    ): Promise<void> {
+        let common: ioBroker.StateCommon = {
+            name: `${controlName}: ${name}`,
+            read: false,
+            write: true,
+            type: 'boolean',
+            role: 'button',
+            // TODO: re-add: smartIgnore: true,
+        };
+        if (commonExt && typeof commonExt === 'object') {
+            common = { ...common, ...commonExt };
+        }
+        await this.updateStateObjectAsync(`${uuid}.${this.normalizeName(name)}`, common, uuid);
+    }
+
+    protected async createNumberInputStateObjectAsync(
+        controlName: string,
+        uuid: string,
+        name: string,
+        role: string,
+        commonExt?: Partial<ioBroker.StateCommon>,
+    ): Promise<void> {
+        let common: ioBroker.StateCommon = {
+            name: `${controlName}: ${name}`,
+            read: false,
+            write: true,
+            type: 'number',
+            role: role,
+            // TODO: re-add: smartIgnore: true,
+        };
+        if (commonExt && typeof commonExt === 'object') {
+            common = { ...common, ...commonExt };
+        }
+        await this.updateStateObjectAsync(`${uuid}.${this.normalizeName(name)}`, common, uuid);
+    }
+
+    protected normalizeName(name: string): string {
+        return name.trim().replace(/[^\wäöüÄÖÜäöüéàèêçß]+/g, '_');
+    }
+}

package/src/lxcommunicator.d.ts

@@ -0,0 +1 @@
+declare module 'lxcommunicator';

package/src/main.test.ts

@@ -0,0 +1,24 @@
+/**
+ * This is a dummy TypeScript test file using chai and mocha
+ *
+ * It's automatically excluded from npm and its build output is excluded from both git and npm.
+ * It is advised to test all your modules with accompanying *.test.ts-files
+ */
+
+import { expect } from 'chai';
+// import { functionToTest } from "./moduleToTest";
+
+describe('module to test => function to test', () => {
+    // initializing logic
+    const expected = 5;
+
+    it(`should return ${expected}`, () => {
+        const result = 5;
+        // assign result a value from functionToTest
+        expect(result).to.equal(expected);
+        // or using the should() syntax
+        result.should.equal(expected);
+    });
+    // ... more tests => it
+});
+// ... more test suites => describe