hoffmation-base 3.0.0-alpha.9 → 3.0.0-alpha.90

package/lib/server/devices/smartGarden/smartGardenValve.d.ts

@@ -0,0 +1,36 @@
+import { SmartGardenDevice } from './smartGardenDevice';
+import { iActuator } from '../baseDeviceInterfaces';
+import { ActuatorSetStateCommand, ActuatorSettings, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, RestoreTargetAutomaticValueCommand } from '../../../models';
+import { BlockAutomaticHandler } from '../../services/blockAutomaticHandler';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+export declare class SmartGardenValve extends SmartGardenDevice implements iActuator {
+    /** @inheritDoc */
+    readonly blockAutomationHandler: BlockAutomaticHandler;
+    /** @inheritDoc */
+    targetAutomaticState: boolean;
+    /** @inheritDoc */
+    settings: ActuatorSettings;
+    /** @inheritDoc */
+    queuedValue: boolean | null;
+    private _lastPersist;
+    private readonly _durationValueStateId;
+    private readonly _stopAllValvesStateId;
+    private _actuatorOn;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
+    get actuatorOn(): boolean;
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    setActuator(command: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
+    persist(): void;
+    /** @inheritDoc */
+    toggleActuator(command: ActuatorToggleCommand): boolean;
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
+    private stopIrrigation;
+    private irrigate;
+}

package/lib/server/devices/smartGarden/smartGardenValve.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartGardenValve = void 0;
+const smartGardenDevice_1 = require("./smartGardenDevice");
+const models_1 = require("../../../models");
+const blockAutomaticHandler_1 = require("../../services/blockAutomaticHandler");
+const deviceType_1 = require("../deviceType");
+const DeviceCapability_1 = require("../DeviceCapability");
+const sharedFunctions_1 = require("../sharedFunctions");
+const services_1 = require("../../services");
+// TODO: Add iValve interface and DeviceCapability
+class SmartGardenValve extends smartGardenDevice_1.SmartGardenDevice {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.SmartGardenValve);
+        /** @inheritDoc */
+        this.targetAutomaticState = false;
+        /** @inheritDoc */
+        this.settings = new models_1.ActuatorSettings();
+        /** @inheritDoc */
+        this.queuedValue = null;
+        this._lastPersist = 0;
+        this._actuatorOn = false;
+        this._durationValueStateId = `${pInfo.fullID}.SERVICE_VALVE_${this._deviceSerial}.duration_value`;
+        this._stopAllValvesStateId = `${pInfo.fullID}.SERVICE_VALVE_SET_${this._deviceSerial}.stop_all_valves_i`;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.actuator);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.blockAutomatic);
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+    }
+    /** @inheritDoc */
+    get actuatorOn() {
+        return this._actuatorOn;
+    }
+    /** @inheritDoc */
+    restoreTargetAutomaticValue(c) {
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState));
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.queuedValue = null;
+        super.update(idSplit, state, initial, true);
+        if (idSplit.length < 6) {
+            return;
+        }
+        const folder = idSplit[4];
+        const stateName = idSplit[5];
+        if (folder.indexOf('SERVICE_VALVE') === 0) {
+            switch (stateName) {
+                case 'activity_value':
+                    this._actuatorOn = state.val !== 'CLOSED';
+                    this.persist();
+                    break;
+            }
+        }
+    }
+    /** @inheritDoc */
+    setActuator(command) {
+        if (this._durationValueStateId === '') {
+            this.log(models_1.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        sharedFunctions_1.LampUtils.setActuator(this, command);
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        const now = services_1.Utils.nowMS();
+        if (this._lastPersist + 1000 > now) {
+            return;
+        }
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        this._lastPersist = now;
+    }
+    /** @inheritDoc */
+    toggleActuator(command) {
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this._actuatorOn;
+        const setStateCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, command);
+        this.setActuator(setStateCommand);
+        return newVal;
+    }
+    /** @inheritDoc */
+    writeActuatorStateToDevice(c) {
+        if (!c.stateValue) {
+            this.stopIrrigation();
+            return;
+        }
+        // TODO: Add settings for duration
+        this.irrigate(15 * 60);
+    }
+    stopIrrigation() {
+        this.log(models_1.LogLevel.Info, 'Stopping irrigation until next task');
+        this.setState(this._stopAllValvesStateId, 'STOP_UNTIL_NEXT_TASK', undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Stopping irrigation immediately resulted in error: ${err}`);
+        });
+        this.setState(this._durationValueStateId, 'STOP_UNTIL_NEXT_TASK', undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Prevent irrigation restart resulted in error: ${err}`);
+        });
+    }
+    irrigate(durationInSeconds) {
+        this.log(models_1.LogLevel.Info, `Start irrigation for ${durationInSeconds} seconds`);
+        this.setState(this._durationValueStateId, durationInSeconds.toString(10), undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Starting irrigation resulted in error: ${err}`);
+        });
+    }
+}
+exports.SmartGardenValve = SmartGardenValve;

package/lib/server/devices/tuya/tuyaDevice.d.ts

@@ -5,8 +5,9 @@ import { DeviceType } from '../deviceType';
 export declare class TuyaDevice extends IoBrokerBaseDevice implements iDisposable {
     private _lastUpdate;
     get lastUpdate(): Date;
-    stateMap: Map<string, ioBroker.State>;
     constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
     dispose(): void;
 }

package/lib/server/devices/tuya/tuyaDevice.js

@@ -10,8 +10,8 @@ class TuyaDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     constructor(pInfo, pType) {
         super(pInfo, pType);
         this._lastUpdate = new Date(0);
-        this.stateMap = new Map();
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, pOverride = false) {
         this.log(models_1.LogLevel.DeepTrace, `Tuya: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         if (!pOverride) {
@@ -29,6 +29,7 @@ class TuyaDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
             }
         }
     }
+    /** @inheritDoc */
     dispose() {
         // Nothing yet
     }

package/lib/server/devices/tuya/tuyaGarageOpener.d.ts

@@ -3,6 +3,7 @@ import { GarageDoorOpenerSettings } from '../../../models';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { iGarageDoorOpener } from '../baseDeviceInterfaces';
 export declare class TuyaGarageOpener extends TuyaDevice implements iGarageDoorOpener {
+    /** @inheritDoc */
     settings: GarageDoorOpenerSettings;
     private readonly _switchId;
     private readonly _doorContactId;
@@ -10,9 +11,11 @@ export declare class TuyaGarageOpener extends TuyaDevice implements iGarageDoorO
     private _switchState;
     get isClosed(): boolean;
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     open(): void;
     close(): void;
     trigger(): void;
+    /** @inheritDoc */
     dispose(): void;
 }

package/lib/server/devices/tuya/tuyaGarageOpener.js

@@ -11,6 +11,7 @@ class TuyaGarageOpener extends tuyaDevice_1.TuyaDevice {
     }
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.TuyaGarageDoorOpener);
+        /** @inheritDoc */
         this.settings = new models_1.GarageDoorOpenerSettings();
         this._isClosed = true;
         this._switchState = false;
@@ -18,6 +19,7 @@ class TuyaGarageOpener extends tuyaDevice_1.TuyaDevice {
         this._switchId = `${this.info.fullID}.1`;
         this._doorContactId = `${this.info.fullID}.3`;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         const fullId = idSplit.join('.');
         switch (fullId) {
@@ -59,6 +61,7 @@ class TuyaGarageOpener extends tuyaDevice_1.TuyaDevice {
     trigger() {
         this.setState(this._switchId, !this._switchState);
     }
+    /** @inheritDoc */
     dispose() {
         super.dispose();
     }

package/lib/server/devices/tv/samsungTv.d.ts

@@ -1,6 +1,7 @@
 import { TvDevice } from './tvDevice';
 import { DeviceType } from '../deviceType';
 export declare class SamsungTv extends TvDevice {
+    /** @inheritDoc */
     deviceType: DeviceType;
     private _device;
     constructor(name: string, roomName: string, ip: string, mac: string, token: string);

package/lib/server/devices/tv/samsungTv.js

@@ -32,6 +32,7 @@ const models_1 = require("../../../models");
 class SamsungTv extends tvDevice_1.TvDevice {
     constructor(name, roomName, ip, mac, token) {
         super(name, roomName, ip, tvDeviceType_1.TvDeviceType.Samsung);
+        /** @inheritDoc */
         this.deviceType = deviceType_1.DeviceType.SamsungTv;
         this._on = false;
         this._device = new samsung_tv_control_1.default({

package/lib/server/devices/tv/tvDevice.d.ts

@@ -7,13 +7,19 @@ import { TvDeviceType } from './tvDeviceType';
 export declare abstract class TvDevice implements iTvDevice {
     ip: string;
     tvDeviceType: TvDeviceType;
+    /** @inheritDoc */
     settings: TvSettings;
+    /**
+     * @inheritDoc
+     */
     room: RoomBase | undefined;
+    /**
+     * @inheritDoc
+     */
     deviceCapabilities: DeviceCapability[];
     protected constructor(name: string, roomName: string, ip: string, tvDeviceType: TvDeviceType);
     protected _info: DeviceInfo;
     get info(): DeviceInfo;
-    set info(info: DeviceInfo);
     abstract get deviceType(): DeviceType;
     get name(): string;
     get id(): string;

package/lib/server/devices/tv/tvDevice.js

@@ -13,7 +13,11 @@ class TvDevice {
     constructor(name, roomName, ip, tvDeviceType) {
         this.ip = ip;
         this.tvDeviceType = tvDeviceType;
+        /** @inheritDoc */
         this.settings = new models_1.TvSettings();
+        /**
+         * @inheritDoc
+         */
         this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.tv];
         this._info = new devices_1.DeviceInfo();
         this._info.fullName = `TV ${name}`;
@@ -27,9 +31,6 @@ class TvDevice {
     get info() {
         return this._info;
     }
-    set info(info) {
-        this._info = info;
-    }
     get name() {
         return this.info.customName;
     }

package/lib/server/devices/velux/index.d.ts

@@ -0,0 +1,4 @@
+export { VeluxDevice } from './veluxDevice';
+export { VeluxShutter } from './veluxShutter';
+export { VeluxDeviceRegistrationInfo } from './veluxDeviceRegistrationInfo';
+export { VeluxService } from './veluxService';

package/lib/server/devices/velux/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxService = exports.VeluxDeviceRegistrationInfo = exports.VeluxShutter = exports.VeluxDevice = void 0;
+var veluxDevice_1 = require("./veluxDevice");
+Object.defineProperty(exports, "VeluxDevice", { enumerable: true, get: function () { return veluxDevice_1.VeluxDevice; } });
+var veluxShutter_1 = require("./veluxShutter");
+Object.defineProperty(exports, "VeluxShutter", { enumerable: true, get: function () { return veluxShutter_1.VeluxShutter; } });
+var veluxDeviceRegistrationInfo_1 = require("./veluxDeviceRegistrationInfo");
+Object.defineProperty(exports, "VeluxDeviceRegistrationInfo", { enumerable: true, get: function () { return veluxDeviceRegistrationInfo_1.VeluxDeviceRegistrationInfo; } });
+var veluxService_1 = require("./veluxService");
+Object.defineProperty(exports, "VeluxService", { enumerable: true, get: function () { return veluxService_1.VeluxService; } });

package/lib/server/devices/velux/veluxDevice.d.ts

@@ -0,0 +1,13 @@
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+import { iDisposable } from '../../services';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { DeviceType } from '../deviceType';
+export declare class VeluxDevice extends IoBrokerBaseDevice implements iDisposable {
+    private _lastUpdate;
+    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    get lastUpdate(): Date;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+}

package/lib/server/devices/velux/veluxDevice.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxDevice = void 0;
+const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
+const DeviceCapability_1 = require("../DeviceCapability");
+const models_1 = require("../../../models");
+class VeluxDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        this._lastUpdate = new Date(0);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
+    }
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, pOverride = false) {
+        this.log(models_1.LogLevel.DeepTrace, `Velux: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        if (!pOverride) {
+            this.log(models_1.LogLevel.Warn, `Keine Update Überschreibung:\n\tID: ${idSplit.join('.')}\n\tData: ${JSON.stringify(state)}`);
+        }
+        const stateLastUpdate = new Date(state.ts);
+        if (stateLastUpdate > this._lastUpdate) {
+            this._lastUpdate = stateLastUpdate;
+        }
+        if (idSplit.length < 5) {
+            return;
+        }
+        const stateName = idSplit[4];
+        this.stateMap.set(stateName, state);
+        const individualCallbacks = this.individualStateCallbacks.get(stateName);
+        if (individualCallbacks !== undefined) {
+            for (const cb of individualCallbacks) {
+                cb(state.val);
+            }
+        }
+    }
+    /** @inheritDoc */
+    dispose() {
+        // Nothing yet
+    }
+}
+exports.VeluxDevice = VeluxDevice;

package/lib/server/devices/velux/veluxDeviceRegistrationInfo.d.ts

@@ -0,0 +1,9 @@
+import { DeviceType } from '../deviceType';
+export declare class VeluxDeviceRegistrationInfo {
+    readonly deviceType: DeviceType;
+    readonly deviceId: string;
+    readonly deviceName: string;
+    readonly room: string;
+    readonly roomIndex: number;
+    constructor(deviceType: DeviceType, deviceId: string, deviceName: string, room: string, roomIndex: number);
+}

package/lib/server/devices/velux/veluxDeviceRegistrationInfo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxDeviceRegistrationInfo = void 0;
+class VeluxDeviceRegistrationInfo {
+    constructor(deviceType, deviceId, deviceName, room, roomIndex) {
+        this.deviceType = deviceType;
+        this.deviceId = deviceId;
+        this.deviceName = deviceName;
+        this.room = room;
+        this.roomIndex = roomIndex;
+    }
+}
+exports.VeluxDeviceRegistrationInfo = VeluxDeviceRegistrationInfo;

package/lib/server/devices/velux/veluxService.d.ts

@@ -0,0 +1,7 @@
+import { deviceConfig } from '../../../models';
+import { VeluxDeviceRegistrationInfo } from './veluxDeviceRegistrationInfo';
+export declare class VeluxService {
+    private static readonly _registeredDevices;
+    static preRegisterDevice(devName: string, registrationInfo: VeluxDeviceRegistrationInfo): void;
+    static processVeluxDevice(cDevConf: deviceConfig): void;
+}

package/lib/server/devices/velux/veluxService.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxService = void 0;
+const models_1 = require("../../../models");
+const services_1 = require("../../services");
+const IoBrokerDeviceInfo_1 = require("../IoBrokerDeviceInfo");
+const deviceType_1 = require("../deviceType");
+const devices_1 = require("../devices");
+const veluxShutter_1 = require("./veluxShutter");
+class VeluxService {
+    static preRegisterDevice(devName, registrationInfo) {
+        this._registeredDevices.set(devName, registrationInfo);
+    }
+    static processVeluxDevice(cDevConf) {
+        var _a;
+        const devName = (_a = cDevConf.common) === null || _a === void 0 ? void 0 : _a.name;
+        if (!devName || typeof devName !== 'string') {
+            return;
+        }
+        const registrationInfo = this._registeredDevices.get(devName);
+        if (!registrationInfo) {
+            services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Velux Device ${devName} not registered`);
+            return;
+        }
+        const ioBrokerDeviceInfo = new IoBrokerDeviceInfo_1.IoBrokerDeviceInfo(cDevConf, registrationInfo.deviceId, deviceType_1.DeviceType[registrationInfo.deviceType], registrationInfo.room, registrationInfo.roomIndex);
+        const fullName = `${devices_1.Devices.IDENTIFIER_VELUX}-${ioBrokerDeviceInfo.devID}`;
+        if (typeof devices_1.Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        ioBrokerDeviceInfo.allDevicesKey = fullName;
+        let d;
+        switch (registrationInfo.deviceType) {
+            case deviceType_1.DeviceType.VeluxShutter:
+                d = new veluxShutter_1.VeluxShutter(ioBrokerDeviceInfo);
+                break;
+            default:
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `No Velux Device Type for ${registrationInfo.deviceType} defined`);
+                return;
+        }
+        devices_1.Devices.alLDevices[fullName] = d;
+    }
+}
+exports.VeluxService = VeluxService;
+VeluxService._registeredDevices = new Map();

package/lib/server/devices/velux/veluxShutter.d.ts

@@ -0,0 +1,27 @@
+import { Window } from '../groups';
+import { ShutterSetLevelCommand, ShutterSettings } from '../../../models';
+import { iShutter } from '../baseDeviceInterfaces';
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { VeluxDevice } from './veluxDevice';
+export declare class VeluxShutter extends VeluxDevice implements iShutter {
+    /** @inheritDoc */
+    settings: ShutterSettings;
+    private readonly _setLevelSwitchID;
+    private _firstCommandRecieved;
+    private _setLevel;
+    private _setLevelTime;
+    private _currentLevel;
+    private _window?;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    get currentLevel(): number;
+    get window(): Window | undefined;
+    set window(value: Window | undefined);
+    get desiredWindowShutterLevel(): number;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    persist(): void;
+    setLevel(command: ShutterSetLevelCommand): void;
+    toJSON(): Partial<IoBrokerBaseDevice>;
+    private setCurrentLevel;
+}

package/lib/server/devices/velux/veluxShutter.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxShutter = void 0;
+const deviceType_1 = require("../deviceType");
+const services_1 = require("../../services");
+const models_1 = require("../models");
+const models_2 = require("../../../models");
+const lodash_1 = __importDefault(require("lodash"));
+const DeviceCapability_1 = require("../DeviceCapability");
+const veluxDevice_1 = require("./veluxDevice");
+class VeluxShutter extends veluxDevice_1.VeluxDevice {
+    constructor(pInfo) {
+        var _a;
+        super(pInfo, deviceType_1.DeviceType.VeluxShutter);
+        /** @inheritDoc */
+        this.settings = new models_2.ShutterSettings();
+        this._firstCommandRecieved = false;
+        this._setLevel = -1;
+        this._setLevelTime = -1;
+        this._currentLevel = -1;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.shutter);
+        this._setLevelSwitchID = `${this.info.fullID}.targetPosition`;
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.getLastDesiredPosition(this).then((val) => {
+            var _a;
+            if (val.desiredPosition === -1) {
+                return;
+            }
+            (_a = this._window) === null || _a === void 0 ? void 0 : _a.setDesiredPosition(new models_2.WindowSetDesiredPositionCommand(models_2.CommandSource.Automatic, val.desiredPosition, 'Found persisted last desired position in DB'));
+        });
+    }
+    get currentLevel() {
+        if (this._setLevel !== -1 && this._currentLevel !== this._setLevel) {
+            return this._setLevel;
+        }
+        return this._currentLevel;
+    }
+    get window() {
+        return this._window;
+    }
+    set window(value) {
+        this._window = value;
+    }
+    get desiredWindowShutterLevel() {
+        if (this._window === undefined) {
+            return -1;
+        }
+        return this._window.desiredPosition;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(models_2.LogLevel.DeepTrace, `Rollo Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[4]) {
+            case 'currentPosition':
+                this.setCurrentLevel(state.val, true);
+                break;
+        }
+    }
+    persist() {
+        var _a;
+        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistShutter(this);
+    }
+    setLevel(command) {
+        let targetLevel = command.level;
+        if (!this._firstCommandRecieved && !command.isInitial) {
+            this._firstCommandRecieved = true;
+        }
+        if (this._firstCommandRecieved && command.isInitial) {
+            this.log(models_2.LogLevel.Debug, `Skipped initial Rollo to ${targetLevel} as we recieved a command already`);
+            return;
+        }
+        if (this.currentLevel === targetLevel && !command.isForceAction) {
+            this.log(models_2.LogLevel.Debug, `Skip Rollo command to Position ${targetLevel} as this is the current one, commandLog: ${command.logMessage}`, services_1.LogDebugType.SkipUnchangedRolloPosition);
+            return;
+        }
+        if (this._setLevelSwitchID === '') {
+            this.log(models_2.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        if (!this.checkIoConnection(true)) {
+            return;
+        }
+        this.log(models_2.LogLevel.Debug, command.logMessage);
+        if (this._window !== undefined) {
+            if (this._window.griffeInPosition(models_1.WindowPosition.open) > 0 && command.level < 100) {
+                if (!command.skipOpenWarning) {
+                    this.log(models_2.LogLevel.Alert, 'Not closing the shutter, as the window is open!');
+                }
+                return;
+            }
+            if (this._window.griffeInPosition(models_1.WindowPosition.tilted) > 0 && targetLevel < 50) {
+                targetLevel = 50;
+                if (!command.skipOpenWarning) {
+                    this.log(models_2.LogLevel.Alert, 'Not closing the shutter, as the window is half open!');
+                }
+            }
+        }
+        this._setLevel = targetLevel;
+        this.log(models_2.LogLevel.Debug, `Fahre Rollo auf Position ${targetLevel}`);
+        // Level is inverted for Velux Adapter (100 = 0, 0 = 100, 25 = 75, etc.)
+        this.setState(this._setLevelSwitchID, Math.abs(targetLevel - 100));
+    }
+    toJSON() {
+        return lodash_1.default.omit(super.toJSON(), ['_window']);
+    }
+    setCurrentLevel(value, initial = false) {
+        let correctedValue = Math.abs(value - 100);
+        if (correctedValue !== this._setLevel && services_1.Utils.nowMS() - this._setLevelTime < 60 * 10000) {
+            correctedValue = this._setLevel;
+        }
+        if (correctedValue !== this._currentLevel && this._window && !initial) {
+            services_1.Utils.guardedNewThread(() => {
+                var _a;
+                (_a = this._window) === null || _a === void 0 ? void 0 : _a.rolloPositionChange(new models_2.ShutterPositionChangedAction(this, correctedValue));
+            }, this);
+            this.persist();
+        }
+        this._currentLevel = correctedValue;
+    }
+}
+exports.VeluxShutter = VeluxShutter;

package/lib/server/devices/wledDevice.d.ts

@@ -4,27 +4,39 @@ import { IoBrokerDeviceInfo } from './IoBrokerDeviceInfo';
 import { iDimmableLamp } from './baseDeviceInterfaces/iDimmableLamp';
 import { BlockAutomaticHandler } from '../services/blockAutomaticHandler';
 export declare class WledDevice extends IoBrokerBaseDevice implements iDimmableLamp {
-    on: boolean;
+    /** @inheritDoc */
     brightness: number;
-    battery: number;
+    /** @inheritDoc */
     queuedValue: boolean | null;
+    /** @inheritDoc */
     settings: WledSettings;
+    /** @inheritDoc */
     readonly blockAutomationHandler: BlockAutomaticHandler;
+    /** @inheritDoc */
     targetAutomaticState: boolean;
+    private on;
+    protected readonly _debounceStateDelay: number;
     private readonly _onID;
     private readonly _presetID;
     private readonly _brightnessID;
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     get actuatorOn(): boolean;
-    get lightOn(): boolean;
+    /** @inheritDoc */
     restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, _pOverride?: boolean): void;
+    /** @inheritDoc */
     setLight(c: DimmerSetLightCommand): void;
     setWled(c: WledSetLightCommand): void;
     setTimeBased(c: LampSetTimeBasedCommand): void;
+    /** @inheritDoc */
     persist(): void;
+    /** @inheritDoc */
     setActuator(command: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
     toggleActuator(c: ActuatorToggleCommand): boolean;
+    /** @inheritDoc */
     toggleLight(c: LampToggleLightCommand): boolean;
+    /** @inheritDoc */
     writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
 }