hoffmation-base 2.23.0 → 3.0.0-alpha.0

package/lib/server/devices/hmIPDevices/hmIpRoll.js

@@ -27,7 +27,7 @@ class HmIpRoll extends hmIpDevice_1.HmIPDevice {
             if (val.desiredPosition === -1) {
                 return;
             }
-            (_a = this._window) === null || _a === void 0 ? void 0 : _a.setDesiredPosition(val.desiredPosition);
+            (_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() {
@@ -76,16 +76,18 @@ class HmIpRoll extends hmIpDevice_1.HmIPDevice {
                 break;
         }
     }
-    setLevel(pPosition, initial = false, skipOpenWarning = false) {
-        if (!this._firstCommandRecieved && !initial) {
+    setLevel(command) {
+        this.log(models_2.LogLevel.Debug, command.logMessage);
+        let targetLevel = command.level;
+        if (!this._firstCommandRecieved && !command.isInitial) {
             this._firstCommandRecieved = true;
         }
-        if (this._firstCommandRecieved && initial) {
-            this.log(models_2.LogLevel.Debug, `Skipped initial Rollo to ${pPosition} as we recieved a command already`);
+        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 === pPosition) {
-            this.log(models_2.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`, services_1.LogDebugType.SkipUnchangedRolloPosition);
+        if (this.currentLevel === targetLevel && !command.isForceAction) {
+            this.log(models_2.LogLevel.Debug, `Skip Rollo command to Position ${targetLevel} as this is the current one`, services_1.LogDebugType.SkipUnchangedRolloPosition);
             return;
         }
         if (this._setLevelSwitchID === '') {
@@ -96,22 +98,22 @@ class HmIpRoll extends hmIpDevice_1.HmIPDevice {
             return;
         }
         if (this._window !== undefined) {
-            if (this._window.griffeInPosition(models_1.WindowPosition.offen) > 0 && pPosition < 100) {
-                if (!skipOpenWarning) {
+            if (this._window.griffeInPosition(models_1.WindowPosition.offen) > 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.kipp) > 0 && pPosition < 50) {
-                pPosition = 50;
-                if (!skipOpenWarning) {
+            if (this._window.griffeInPosition(models_1.WindowPosition.kipp) > 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 = pPosition;
-        this.log(models_2.LogLevel.Debug, `Fahre Rollo auf Position ${pPosition}`);
-        this.setState(this._setLevelSwitchID, pPosition);
+        this._setLevel = targetLevel;
+        this.log(models_2.LogLevel.Debug, `Fahre Rollo auf Position ${targetLevel}`);
+        this.setState(this._setLevelSwitchID, targetLevel);
     }
     toJSON() {
         return lodash_1.default.omit(super.toJSON(), ['_window']);

package/lib/server/devices/sharedFunctions/lampUtils.d.ts

@@ -1,10 +1,11 @@
 import { iActuator, iLamp } from '../baseDeviceInterfaces';
-import { TimeOfDay } from '../../../models';
+import { ActuatorSetStateCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
 export declare class LampUtils {
-    static stromStossOn(lamp: iLamp): void;
-    static setTimeBased(device: iLamp, time: TimeOfDay, timeout: number, force: boolean): void;
-    static checkUnBlock(device: iActuator, force: boolean | undefined, pValue: boolean): boolean;
-    static toggleLight(device: iLamp, time: TimeOfDay | undefined, force: boolean, calculateTime: boolean): boolean;
-    static checkBlockActive(device: iActuator, force: boolean | undefined, pValue: boolean): boolean;
-    static checkUnchanged(device: iActuator, force: boolean, pValue: boolean): boolean;
+    static stromStossOn(actuator: iActuator): void;
+    static setTimeBased(device: iLamp, c: LampSetTimeBasedCommand): void;
+    static checkUnBlock(device: iActuator, command: ActuatorSetStateCommand): boolean;
+    static toggleLight(device: iLamp, c: LampToggleLightCommand): boolean;
+    static checkBlockActive(device: iActuator, c: ActuatorSetStateCommand): boolean;
+    static checkUnchanged(device: iActuator, c: ActuatorSetStateCommand): boolean;
+    static setActuator(device: iActuator, c: ActuatorSetStateCommand): void;
 }

package/lib/server/devices/sharedFunctions/lampUtils.js

@@ -4,29 +4,29 @@ exports.LampUtils = void 0;
 const services_1 = require("../../services");
 const models_1 = require("../../../models");
 class LampUtils {
-    static stromStossOn(lamp) {
+    static stromStossOn(actuator) {
         services_1.Utils.guardedTimeout(() => {
             var _a, _b;
-            if ((_b = (_a = lamp.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent()) {
-                lamp.setLight(true, -1, true);
+            if ((_b = (_a = actuator.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent()) {
+                actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Force, true, 'StromStoss On due to Presence'));
             }
-        }, lamp.settings.stromStossResendTime * 1000, this);
+        }, actuator.settings.stromStossResendTime * 1000, this);
         services_1.Utils.guardedTimeout(() => {
-            lamp.setLight(false, -1, true);
+            actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Force, false, 'StromStoss Off'));
         }, 3000, this);
     }
-    static setTimeBased(device, time, timeout, force) {
-        if ((time === models_1.TimeOfDay.Night && device.settings.nightOn) ||
-            (time === models_1.TimeOfDay.BeforeSunrise && device.settings.dawnOn) ||
-            (time === models_1.TimeOfDay.AfterSunset && device.settings.duskOn)) {
-            device.setLight(true, timeout, force);
+    static setTimeBased(device, c) {
+        if ((c.time === models_1.TimeOfDay.Night && device.settings.nightOn) ||
+            (c.time === models_1.TimeOfDay.BeforeSunrise && device.settings.dawnOn) ||
+            (c.time === models_1.TimeOfDay.AfterSunset && device.settings.duskOn)) {
+            device.setLight(new models_1.LampSetLightCommand(c, true, `SetLight due to TimeBased ${c.time}`, c.timeout));
         }
     }
-    static checkUnBlock(device, force, pValue) {
+    static checkUnBlock(device, command) {
         let dontBlock = false;
-        if (force &&
+        if (command.isForceAction &&
             device.settings.resetToAutomaticOnForceOffAfterForceOn &&
-            !pValue &&
+            !command.on &&
             device.blockAutomationHandler.automaticBlockActive) {
             dontBlock = true;
             device.log(models_1.LogLevel.Debug, `Reset Automatic Block as we are turning off manually after a force on`);
@@ -34,34 +34,54 @@ class LampUtils {
         }
         return dontBlock;
     }
-    static toggleLight(device, time, force, calculateTime) {
+    static toggleLight(device, c) {
         var _a;
         const newVal = device.queuedValue !== null ? !device.queuedValue : !device.lightOn;
-        const timeout = newVal && force ? 30 * 60 * 1000 : -1;
-        if (newVal && time === undefined && calculateTime && device.room !== undefined) {
-            time = services_1.TimeCallbackService.dayType((_a = device.room) === null || _a === void 0 ? void 0 : _a.settings.lampOffset);
+        const timeout = newVal && c.isForceAction ? 30 * 60 * 1000 : -1;
+        if (newVal && c.time === undefined && c.calculateTime && device.room !== undefined) {
+            c.time = services_1.TimeCallbackService.dayType((_a = device.room) === null || _a === void 0 ? void 0 : _a.settings.lampOffset);
         }
-        if (newVal && time !== undefined) {
-            device.setTimeBased(time, timeout, force);
+        if (newVal && c.time !== undefined) {
+            device.setTimeBased(new models_1.LampSetTimeBasedCommand(c, c.time, 'SetLight Due to toggle Light', timeout));
             return true;
         }
-        device.setLight(newVal, timeout, force);
+        device.setLight(new models_1.LampSetLightCommand(c, newVal, 'SetLight Due to toggle Light', timeout));
         return newVal;
     }
-    static checkBlockActive(device, force, pValue) {
-        if (!force && device.blockAutomationHandler.automaticBlockActive) {
-            device.log(models_1.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(device.blockAutomationHandler.automaticBlockedUntil).toLocaleTimeString()}`);
-            device.targetAutomaticState = pValue;
+    static checkBlockActive(device, c) {
+        if (!c.isForceAction && device.blockAutomationHandler.automaticBlockActive) {
+            device.log(models_1.LogLevel.Debug, `Skip automatic command to ${c.on} as it is locked until ${new Date(device.blockAutomationHandler.automaticBlockedUntil).toLocaleTimeString()}`);
+            device.targetAutomaticState = c.on;
             return true;
         }
         return false;
     }
-    static checkUnchanged(device, force, pValue) {
-        if (!force && pValue === device.actuatorOn && device.queuedValue === null) {
-            device.log(models_1.LogLevel.DeepTrace, `Skip light command as it is already ${pValue}`, services_1.LogDebugType.SkipUnchangedActuatorCommand);
+    static checkUnchanged(device, c) {
+        if (!c.isForceAction && c.on === device.actuatorOn && device.queuedValue === null) {
+            device.log(models_1.LogLevel.DeepTrace, `Skip light command as it is already ${c.on}`, services_1.LogDebugType.SkipUnchangedActuatorCommand);
             return true;
         }
         return false;
     }
+    static setActuator(device, c) {
+        if (LampUtils.checkBlockActive(device, c)) {
+            return;
+        }
+        if (LampUtils.checkUnchanged(device, c)) {
+            return;
+        }
+        device.queuedValue = c.on;
+        device.writeActuatorStateToDevice(new models_1.ActuatorWriteStateToDeviceCommand(c.on, c));
+        if (device.settings.isStromStoss && c.on) {
+            c.timeout = 3000;
+            LampUtils.stromStossOn(device);
+        }
+        if (c.timeout < 0 || !c.on) {
+            return;
+        }
+        if (c.timeout > -1 && device.blockAutomationHandler !== undefined) {
+            device.blockAutomationHandler.disableAutomatic(c.timeout, models_1.CollisionSolving.overrideIfGreater);
+        }
+    }
 }
 exports.LampUtils = LampUtils;

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

@@ -1,5 +1,5 @@
 import { IoBrokerBaseDevice } from './IoBrokerBaseDevice';
-import { TimeOfDay, WledSettings } from '../../models';
+import { ActuatorSetStateCommand, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, DimmerSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand, RestoreTargetAutomaticValueCommand, WledSetLightCommand, WledSettings } from '../../models';
 import { IoBrokerDeviceInfo } from './IoBrokerDeviceInfo';
 import { iDimmableLamp } from './baseDeviceInterfaces/iDimmableLamp';
 import { BlockAutomaticHandler } from '../services/blockAutomaticHandler';
@@ -17,13 +17,14 @@ export declare class WledDevice extends IoBrokerBaseDevice implements iDimmableL
     constructor(pInfo: IoBrokerDeviceInfo);
     get actuatorOn(): boolean;
     get lightOn(): boolean;
-    restoreTargetAutomaticValue(): void;
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, _pOverride?: boolean): void;
-    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, _transitionTime?: number): void;
-    setWled(pValue: boolean, brightness?: number, preset?: number, timeout?: number, force?: boolean): void;
-    setTimeBased(time: TimeOfDay): void;
+    setLight(c: DimmerSetLightCommand): void;
+    setWled(c: WledSetLightCommand): void;
+    setTimeBased(c: LampSetTimeBasedCommand): void;
     persist(): void;
-    setActuator(pValue: boolean, _timeout?: number, _force?: boolean): void;
-    toggleActuator(_force: boolean): boolean;
-    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
+    setActuator(command: ActuatorSetStateCommand): void;
+    toggleActuator(c: ActuatorToggleCommand): boolean;
+    toggleLight(c: LampToggleLightCommand): boolean;
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
 }

package/lib/server/devices/wledDevice.js

@@ -27,9 +27,9 @@ class WledDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     get lightOn() {
         return this.on;
     }
-    restoreTargetAutomaticValue() {
-        this.log(models_1.LogLevel.Debug, `Restore Target Automatic value`);
-        this.setActuator(this.targetAutomaticState);
+    restoreTargetAutomaticValue(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage);
+        this.setLight(new models_1.WledSetLightCommand(c, this.targetAutomaticState, 'Lampen RestoreTargetAutomaticValue'));
     }
     update(idSplit, state, initial = false, _pOverride = false) {
         this.queuedValue = null;
@@ -43,10 +43,11 @@ class WledDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
                 break;
         }
     }
-    setLight(pValue, timeout, force, brightness, _transitionTime) {
-        this.setWled(pValue, brightness, undefined, timeout, force);
+    setLight(c) {
+        this.setWled(new models_1.WledSetLightCommand(c, c.on, 'Set Wled due to DimmerSetLightCommand', c.timeout, c.brightness, c.transitionTime, undefined));
     }
-    setWled(pValue, brightness = -1, preset, timeout, force) {
+    setWled(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage);
         if (this._onID === '') {
             services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Keine On ID für "${this.info.customName}" bekannt.`);
             return;
@@ -55,70 +56,54 @@ class WledDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
             services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
             return;
         }
-        const dontBlock = sharedFunctions_1.LampUtils.checkUnBlock(this, force, pValue);
-        if (sharedFunctions_1.LampUtils.checkBlockActive(this, force, pValue)) {
+        const dontBlock = sharedFunctions_1.LampUtils.checkUnBlock(this, c);
+        if (sharedFunctions_1.LampUtils.checkBlockActive(this, c)) {
             return;
         }
-        if (pValue && brightness !== -1 && this.brightness < 10) {
-            brightness = 10;
+        if (c.on && c.brightness !== -1 && this.brightness < 10) {
+            c.brightness = 10;
         }
-        services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `WLED Schalten: "${this.info.customName}" An: ${pValue}\tHelligkeit: ${brightness}%`);
-        this.queuedValue = pValue;
-        this.setState(this._onID, pValue, undefined, (err) => {
-            services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `WLED schalten ergab Fehler: ${err}`);
-        });
-        if (preset !== undefined) {
-            this.setState(this._presetID, preset, undefined, (err) => {
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `WLED Schalten: "${this.info.customName}" An: ${c.on}\tHelligkeit: ${c.brightness}%`);
+        this.queuedValue = c.on;
+        this.writeActuatorStateToDevice(new models_1.ActuatorWriteStateToDeviceCommand(c.on, c, 'WLED Schalten'));
+        if (c.preset !== undefined) {
+            this.setState(this._presetID, c.preset, undefined, (err) => {
                 services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `WLED schalten ergab Fehler: ${err}`);
             });
         }
-        else if (brightness > -1) {
-            this.setState(this._brightnessID, brightness, undefined, (err) => {
+        else if (c.brightness > -1) {
+            this.setState(this._brightnessID, c.brightness, undefined, (err) => {
                 services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Dimmer Helligkeit schalten ergab Fehler: ${err}`);
             });
         }
-        if (timeout !== undefined && timeout > -1 && !dontBlock) {
-            this.blockAutomationHandler.disableAutomatic(timeout, models_1.CollisionSolving.overrideIfGreater);
+        if (c.timeout !== undefined && c.timeout > -1 && !dontBlock) {
+            this.blockAutomationHandler.disableAutomatic(c.timeout, models_1.CollisionSolving.overrideIfGreater);
         }
     }
-    setTimeBased(time) {
-        this.log(models_1.LogLevel.Debug, `Wled setTimeBased ${time}`);
-        switch (time) {
-            case models_1.TimeOfDay.Night:
-                if (this.settings.nightOn) {
-                    this.setWled(true, this.settings.nightBrightness, this.settings.nightPreset);
-                }
-                break;
-            case models_1.TimeOfDay.AfterSunset:
-                if (this.settings.duskOn) {
-                    this.setWled(true, this.settings.duskBrightness, this.settings.duskPreset);
-                }
-                break;
-            case models_1.TimeOfDay.BeforeSunrise:
-                if (this.settings.dawnOn) {
-                    this.setWled(true, this.settings.dawnBrightness, this.settings.dawnPreset);
-                }
-                break;
-            case models_1.TimeOfDay.Daylight:
-                if (this.settings.dayOn) {
-                    this.setWled(true, this.settings.dayBrightness, this.settings.dayPreset);
-                }
-                break;
-        }
+    setTimeBased(c) {
+        this.log(models_1.LogLevel.Debug, `Wled setTimeBased ${c.time}`);
+        this.setWled(models_1.WledSetLightCommand.byTimeBased(this.settings, c));
     }
     persist() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
     }
-    setActuator(pValue, _timeout, _force) {
-        this.setLight(pValue);
+    setActuator(command) {
+        this.setWled(new models_1.WledSetLightCommand(command, command.on, 'Set Wled due to ActuatorSetStateCommand'));
     }
-    toggleActuator(_force) {
-        this.setLight(!this.on);
-        return this.on;
+    toggleActuator(c) {
+        const setActuatorCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, c);
+        this.setActuator(setActuatorCommand);
+        return setActuatorCommand.on;
+    }
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
     }
-    toggleLight(time, force = false, calculateTime = false) {
-        return sharedFunctions_1.LampUtils.toggleLight(this, time, force, calculateTime);
+    writeActuatorStateToDevice(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage, services_1.LogDebugType.SetActuator);
+        this.setState(this._onID, c.stateValue, undefined, (err) => {
+            services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `WLED schalten ergab Fehler: ${err}`);
+        });
     }
 }
 exports.WledDevice = WledDevice;

package/lib/server/devices/zigbee/BaseDevices/ZigbeeActuator.d.ts

@@ -1,4 +1,4 @@
-import { ActuatorSettings } from '../../../../models';
+import { ActuatorSetStateCommand, ActuatorSettings, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, RestoreTargetAutomaticValueCommand } from '../../../../models';
 import { DeviceType } from '../../deviceType';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
 import { iActuator } from '../../baseDeviceInterfaces';
@@ -13,9 +13,10 @@ export declare class ZigbeeActuator extends ZigbeeDevice implements iActuator {
     queuedValue: boolean | null;
     get actuatorOn(): boolean;
     constructor(pInfo: IoBrokerDeviceInfo, type: DeviceType, actuatorOnSwitchID: string);
-    restoreTargetAutomaticValue(): void;
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
-    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
+    setActuator(command: ActuatorSetStateCommand): void;
     persist(): void;
-    toggleActuator(force?: boolean): boolean;
+    toggleActuator(command: ActuatorToggleCommand): boolean;
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
 }

package/lib/server/devices/zigbee/BaseDevices/ZigbeeActuator.js

@@ -22,9 +22,9 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
         this.actuatorOnSwitchID = actuatorOnSwitchID;
         this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this));
     }
-    restoreTargetAutomaticValue() {
+    restoreTargetAutomaticValue(c) {
         this.log(models_1.LogLevel.Debug, `Restore Target Automatic value`);
-        this.setActuator(this.targetAutomaticState);
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState, 'Restore Target Automatic value'));
     }
     update(idSplit, state, initial = false, handledByChildObject = false) {
         if (!handledByChildObject) {
@@ -42,36 +42,28 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
                 break;
         }
     }
-    setActuator(pValue, timeout = -1, force = false) {
+    setActuator(command) {
         if (this.actuatorOnSwitchID === '') {
             this.log(models_1.LogLevel.Error, `Keine Switch ID bekannt.`);
             return;
         }
-        const dontBlock = sharedFunctions_1.LampUtils.checkUnBlock(this, force, pValue);
-        if (sharedFunctions_1.LampUtils.checkBlockActive(this, force, pValue)) {
-            return;
-        }
-        if (sharedFunctions_1.LampUtils.checkUnchanged(this, force, pValue)) {
-            return;
-        }
-        this.log(models_1.LogLevel.Debug, `Set Acutator to "${pValue}"`, services_1.LogDebugType.SetActuator);
-        this.setState(this.actuatorOnSwitchID, pValue, undefined, (err) => {
-            this.log(models_1.LogLevel.Error, `Switching actuator resulted in error: ${err}`);
-        });
-        this.queuedValue = pValue;
-        if (timeout > -1 && !dontBlock) {
-            this.blockAutomationHandler.disableAutomatic(timeout, models_1.CollisionSolving.overrideIfGreater);
-        }
+        sharedFunctions_1.LampUtils.setActuator(this, command);
     }
     persist() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
     }
-    toggleActuator(force = false) {
+    toggleActuator(command) {
         const newVal = this.queuedValue !== null ? !this.queuedValue : !this._actuatorOn;
-        const timeout = newVal && force ? 30 * 60 * 1000 : -1;
-        this.setActuator(newVal, timeout, force);
+        const timeout = newVal && command.isForceAction ? 30 * 60 * 1000 : -1;
+        this.setActuator(new models_1.ActuatorSetStateCommand(command, newVal, 'Due to ZigbeeActuatorToggle', timeout));
         return newVal;
     }
+    writeActuatorStateToDevice(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage, services_1.LogDebugType.SetActuator);
+        this.setState(this.actuatorOnSwitchID, c.stateValue, undefined, (err) => {
+            this.log(models_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
+        });
+    }
 }
 exports.ZigbeeActuator = ZigbeeActuator;

package/lib/server/devices/zigbee/BaseDevices/zigbeeDimmer.d.ts

@@ -1,4 +1,4 @@
-import { DimmerSettings, TimeOfDay } from '../../../../models';
+import { ActuatorSetStateCommand, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, DimmerSetLightCommand, DimmerSettings, LampSetTimeBasedCommand, LampToggleLightCommand, RestoreTargetAutomaticValueCommand } from '../../../../models';
 import { DeviceType } from '../../deviceType';
 import { ZigbeeDevice } from './index';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
@@ -25,21 +25,17 @@ export declare abstract class ZigbeeDimmer extends ZigbeeDevice implements iDimm
     protected _transitionTime: number;
     get transitionTime(): number;
     get actuatorOn(): boolean;
-    restoreTargetAutomaticValue(): void;
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
-    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleActuator(force: boolean): boolean;
+    setTimeBased(c: LampSetTimeBasedCommand): void;
+    setActuator(c: ActuatorSetStateCommand): void;
+    toggleActuator(c: ActuatorToggleCommand): boolean;
     /**
      * @inheritDoc
-     * @param pValue The desired value
-     * @param timeout If > 0 time at which this should be turned off again
-     * @param force if it is an user based action which should override automatic ones
-     * @param {number} brightness The desired brightness in percent
-     * @param {number} transitionTime The transition time for the brightness, to switch smoothly
      */
-    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number): void;
+    setLight(c: DimmerSetLightCommand): void;
     persist(): void;
-    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
+    toggleLight(c: LampToggleLightCommand): boolean;
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
     private setBrightnessState;
 }

package/lib/server/devices/zigbee/BaseDevices/zigbeeDimmer.js

@@ -34,9 +34,8 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
     get actuatorOn() {
         return this.lightOn;
     }
-    restoreTargetAutomaticValue() {
-        this.log(models_1.LogLevel.Debug, `Restore Target Automatic value`);
-        this.setActuator(this.targetAutomaticState);
+    restoreTargetAutomaticValue(c) {
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState, 'Restore targetAutomaticState due to BlockAutomaticHandler'));
     }
     update(idSplit, state, initial = false) {
         this.queuedValue = null;
@@ -59,37 +58,21 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
                 break;
         }
     }
-    setTimeBased(time, timeout = -1, force = false) {
-        switch (time) {
-            case models_1.TimeOfDay.Night:
-                this.setLight(true, timeout, force, this.settings.nightBrightness);
-                break;
-            case models_1.TimeOfDay.AfterSunset:
-                this.setLight(true, timeout, force, this.settings.dawnBrightness);
-                break;
-            case models_1.TimeOfDay.BeforeSunrise:
-                this.setLight(true, timeout, force, this.settings.duskBrightness);
-                break;
-            case models_1.TimeOfDay.Daylight:
-                this.setLight(true, timeout, force, this.settings.dayBrightness);
-                break;
-        }
+    setTimeBased(c) {
+        this.setLight(models_1.DimmerSetLightCommand.byTimeBased(this.settings, c));
     }
-    setActuator(pValue, timeout, force) {
-        this.setLight(pValue, timeout, force);
+    setActuator(c) {
+        this.setLight(new models_1.DimmerSetLightCommand(c, c.on, 'Set dimmer due to set ActuactorCommand', c.timeout));
     }
-    toggleActuator(force) {
-        return this.toggleLight(undefined, force);
+    toggleActuator(c) {
+        const setActuatorCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, c);
+        this.setActuator(setActuatorCommand);
+        return setActuatorCommand.on;
     }
     /**
      * @inheritDoc
-     * @param pValue The desired value
-     * @param timeout If > 0 time at which this should be turned off again
-     * @param force if it is an user based action which should override automatic ones
-     * @param {number} brightness The desired brightness in percent
-     * @param {number} transitionTime The transition time for the brightness, to switch smoothly
      */
-    setLight(pValue, timeout = -1, force = false, brightness = -1, transitionTime = -1) {
+    setLight(c) {
         var _a;
         if (this._stateIdState === '') {
             this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
@@ -99,34 +82,34 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
             this.log(models_1.LogLevel.Error, `Keine Connection bekannt.`);
             return;
         }
-        if (transitionTime > -1) {
-            this.setState(this._stateIdTransitionTime, transitionTime);
+        if (c.transitionTime > -1) {
+            this.setState(this._stateIdTransitionTime, c.transitionTime);
         }
-        const dontBlock = sharedFunctions_1.LampUtils.checkUnBlock(this, force, pValue);
-        if (sharedFunctions_1.LampUtils.checkBlockActive(this, force, pValue)) {
+        const dontBlock = sharedFunctions_1.LampUtils.checkUnBlock(this, c);
+        if (sharedFunctions_1.LampUtils.checkBlockActive(this, c)) {
             return;
         }
-        if (pValue && brightness <= 0 && this.brightness < 10) {
-            brightness = 10;
+        if (c.on && c.brightness <= 0 && this.brightness < 10) {
+            c.brightness = 10;
         }
-        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}" with brightness ${brightness}`, services_1.LogDebugType.SetActuator);
-        if (timeout > -1 && !dontBlock) {
-            this.blockAutomationHandler.disableAutomatic(timeout, models_1.CollisionSolving.overrideIfGreater);
+        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${c.on}" with brightness ${c.brightness}`, services_1.LogDebugType.SetActuator);
+        if (c.timeout > -1 && !dontBlock) {
+            this.blockAutomationHandler.disableAutomatic(c.timeout, models_1.CollisionSolving.overrideIfGreater);
         }
-        if (((_a = services_1.SettingsService.settings.ioBroker) === null || _a === void 0 ? void 0 : _a.useZigbee2mqtt) && !pValue) {
+        if (((_a = services_1.SettingsService.settings.ioBroker) === null || _a === void 0 ? void 0 : _a.useZigbee2mqtt) && !c.on) {
             // With zigbee2mqtt to turn on only setting brighness>0 is needed, so we need state only for turning off
-            this.setState(this._stateIdState, pValue);
-            this.queuedValue = pValue;
+            this.writeActuatorStateToDevice(new models_1.ActuatorWriteStateToDeviceCommand(c.on, c, 'Set dimmer due to set ActuactorCommand'));
+            this.queuedValue = c.on;
             return;
         }
-        if (brightness >= this.settings.turnOnThreshhold) {
-            this.setBrightnessState(brightness);
+        if (c.brightness >= this.settings.turnOnThreshhold) {
+            this.setBrightnessState(c.brightness);
             return;
         }
         this.setBrightnessState(this.settings.turnOnThreshhold, () => {
             services_1.Utils.guardedTimeout(() => {
                 this.log(models_1.LogLevel.Info, `Delayed reduced brightness on ${this.info.customName}`);
-                this.setBrightnessState(brightness);
+                this.setBrightnessState(c.brightness);
             }, 1000, this);
         });
     }
@@ -139,8 +122,12 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
         this._lastPersist = now;
     }
-    toggleLight(time, force = false, calculateTime = false) {
-        return sharedFunctions_1.LampUtils.toggleLight(this, time, force, calculateTime);
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
+    }
+    writeActuatorStateToDevice(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage, services_1.LogDebugType.SetActuator);
+        this.setState(this._stateIdState, c.stateValue);
     }
     setBrightnessState(brightness, onSuccess) {
         this.setState(this._stateIdBrightness, Math.max(0, Math.min(brightness, 100)), onSuccess);

package/lib/server/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.d.ts

@@ -1,5 +1,5 @@
 import { DeviceType } from '../../deviceType';
-import { LedSettings, TimeOfDay } from '../../../../models';
+import { LampSetTimeBasedCommand, LedSetLightCommand, LedSettings } from '../../../../models';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
 import { iLedRgbCct } from '../../baseDeviceInterfaces/iLedRgbCct';
 import { ZigbeeDimmer } from './zigbeeDimmer';
@@ -19,9 +19,9 @@ export declare abstract class ZigbeeLedRGBCCT extends ZigbeeDimmer implements iL
     /**
      * @inheritDoc
      */
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setTimeBased(c: LampSetTimeBasedCommand): void;
     /**
      * @inheritDoc
      */
-    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number, color?: string, colorTemp?: number): void;
+    setLight(c: LedSetLightCommand): void;
 }