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

package/lib/server/devices/wledDevice.js

@@ -7,29 +7,34 @@ const services_1 = require("../services");
 const models_1 = require("../../models");
 const blockAutomaticHandler_1 = require("../services/blockAutomaticHandler");
 const sharedFunctions_1 = require("./sharedFunctions");
+const DeviceCapability_1 = require("./DeviceCapability");
 class WledDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.WledDevice);
-        this.on = false;
+        /** @inheritDoc */
         this.brightness = -1;
-        this.battery = -1;
+        /** @inheritDoc */
         this.queuedValue = null;
+        /** @inheritDoc */
         this.settings = new models_1.WledSettings();
+        /** @inheritDoc */
         this.targetAutomaticState = false;
+        this.on = false;
+        this._debounceStateDelay = 500;
         this._onID = `${this.info.fullID}.on`;
         this._presetID = `${this.info.fullID}.ps`;
         this._brightnessID = `${this.info.fullID}.bri`;
-        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this));
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.dimmablelamp);
     }
+    /** @inheritDoc */
     get actuatorOn() {
         return this.on;
     }
-    get lightOn() {
-        return this.on;
-    }
+    /** @inheritDoc */
     restoreTargetAutomaticValue(c) {
-        this.log(models_1.LogLevel.Debug, c.logMessage);
-        this.setLight(new models_1.WledSetLightCommand(c, this.targetAutomaticState, 'Lampen RestoreTargetAutomaticValue'));
+        this.setLight(new models_1.WledSetLightCommand(c, this.targetAutomaticState));
     }
     update(idSplit, state, initial = false, _pOverride = false) {
         this.queuedValue = null;
@@ -43,11 +48,11 @@ class WledDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
                 break;
         }
     }
+    /** @inheritDoc */
     setLight(c) {
-        this.setWled(new models_1.WledSetLightCommand(c, c.on, 'Set Wled due to DimmerSetLightCommand', c.timeout, c.brightness, c.transitionTime, undefined));
+        this.setWled(new models_1.WledSetLightCommand(c, c.on, 'Set Wled due to DimmerSetLightCommand', c.disableAutomaticCommand, c.brightness, c.transitionTime, undefined));
     }
     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;
@@ -60,45 +65,66 @@ class WledDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
         if (sharedFunctions_1.LampUtils.checkBlockActive(this, c)) {
             return;
         }
+        if (c.isAutomaticAction) {
+            // Preserve the target state for the automatic handler, as
+            this.targetAutomaticState = c.on;
+        }
+        if (sharedFunctions_1.LampUtils.canDimmerChangeBeSkipped(this, c)) {
+            return;
+        }
+        this.log(models_1.LogLevel.Debug, c.logMessage);
         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: ${c.on}\tHelligkeit: ${c.brightness}%`);
         this.queuedValue = c.on;
-        this.writeActuatorStateToDevice(new models_1.ActuatorWriteStateToDeviceCommand(c, c.on, 'WLED Schalten'));
-        if (c.preset !== undefined) {
+        if (!c.on) {
+            this.writeActuatorStateToDevice(new models_1.ActuatorWriteStateToDeviceCommand(c, c.on, 'WLED ausschalten'));
+        }
+        else if (c.preset !== undefined) {
+            // This also turns the device on
             this.setState(this._presetID, c.preset, undefined, (err) => {
                 services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `WLED schalten ergab Fehler: ${err}`);
             });
         }
         else if (c.brightness > -1) {
+            // This also turns the device on
             this.setState(this._brightnessID, c.brightness, undefined, (err) => {
                 services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Dimmer Helligkeit schalten ergab Fehler: ${err}`);
             });
         }
-        if (c.timeout !== undefined && c.timeout > -1 && !dontBlock) {
-            this.blockAutomationHandler.disableAutomatic(c.timeout, models_1.CollisionSolving.overrideIfGreater);
+        if (dontBlock || c.disableAutomaticCommand === null) {
+            return;
+        }
+        if (c.disableAutomaticCommand === undefined && c.isForceAction) {
+            c.disableAutomaticCommand = models_1.BlockAutomaticCommand.fromDeviceSettings(c, this.settings);
+        }
+        if (c.disableAutomaticCommand) {
+            this.blockAutomationHandler.disableAutomatic(c.disableAutomaticCommand);
         }
     }
     setTimeBased(c) {
-        this.log(models_1.LogLevel.Debug, `Wled setTimeBased ${c.time}`);
         this.setWled(models_1.WledSetLightCommand.byTimeBased(this.settings, c));
     }
+    /** @inheritDoc */
     persist() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
     }
+    /** @inheritDoc */
     setActuator(command) {
         this.setWled(new models_1.WledSetLightCommand(command, command.on, 'Set Wled due to ActuatorSetStateCommand'));
     }
+    /** @inheritDoc */
     toggleActuator(c) {
         const setActuatorCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, c);
         this.setActuator(setActuatorCommand);
         return setActuatorCommand.on;
     }
+    /** @inheritDoc */
     toggleLight(c) {
         return sharedFunctions_1.LampUtils.toggleLight(this, c);
     }
+    /** @inheritDoc */
     writeActuatorStateToDevice(c) {
         this.log(models_1.LogLevel.Debug, c.logMessage, services_1.LogDebugType.SetActuator);
         this.setState(this._onID, c.stateValue, undefined, (err) => {

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

@@ -4,19 +4,32 @@ import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
 import { iActuator } from '../../baseDeviceInterfaces';
 import { ZigbeeDevice } from './zigbeeDevice';
 import { BlockAutomaticHandler } from '../../../services/blockAutomaticHandler';
-export declare class ZigbeeActuator extends ZigbeeDevice implements iActuator {
-    private _actuatorOn;
+export declare abstract class ZigbeeActuator extends ZigbeeDevice implements iActuator {
+    /** @inheritDoc */
     readonly blockAutomationHandler: BlockAutomaticHandler;
+    /** @inheritDoc */
     targetAutomaticState: boolean;
+    /** @inheritDoc */
     settings: ActuatorSettings;
-    protected readonly actuatorOnSwitchID: string;
+    /** @inheritDoc */
     queuedValue: boolean | null;
+    protected _lastPersist: number;
+    protected abstract readonly _actuatorOnStateIdState: string;
+    protected readonly _stateNameState: string;
+    private _actuatorOn;
+    constructor(pInfo: IoBrokerDeviceInfo, type: DeviceType);
+    /** @inheritDoc */
     get actuatorOn(): boolean;
-    constructor(pInfo: IoBrokerDeviceInfo, type: DeviceType, actuatorOnSwitchID: string);
+    /** @inheritDoc */
     restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    /** @inheritDoc */
     setActuator(command: ActuatorSetStateCommand): void;
+    /** @inheritDoc */
     persist(): void;
+    /** @inheritDoc */
     toggleActuator(command: ActuatorToggleCommand): boolean;
+    /** @inheritDoc */
     writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
 }

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

@@ -8,24 +8,30 @@ const DeviceCapability_1 = require("../../DeviceCapability");
 const blockAutomaticHandler_1 = require("../../../services/blockAutomaticHandler");
 const sharedFunctions_1 = require("../../sharedFunctions");
 class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
-    get actuatorOn() {
-        return this._actuatorOn;
-    }
-    constructor(pInfo, type, actuatorOnSwitchID) {
+    constructor(pInfo, type) {
         super(pInfo, type);
-        this._actuatorOn = false;
+        /** @inheritDoc */
         this.targetAutomaticState = false;
+        /** @inheritDoc */
         this.settings = new models_1.ActuatorSettings();
+        /** @inheritDoc */
         this.queuedValue = null;
+        this._lastPersist = 0;
+        this._stateNameState = 'state';
+        this._actuatorOn = false;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.actuator);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.blockAutomatic);
-        this.actuatorOnSwitchID = actuatorOnSwitchID;
-        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this));
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
     }
+    /** @inheritDoc */
+    get actuatorOn() {
+        return this._actuatorOn;
+    }
+    /** @inheritDoc */
     restoreTargetAutomaticValue(c) {
-        this.log(models_1.LogLevel.Debug, `Restore Target Automatic value`);
-        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState, 'Restore Target Automatic value'));
+        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState));
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, handledByChildObject = false) {
         if (!handledByChildObject) {
             this.log(models_1.LogLevel.DeepTrace, `Aktuator Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
@@ -33,7 +39,7 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
         this.queuedValue = null;
         super.update(idSplit, state, initial, true);
         switch (idSplit[3]) {
-            case 'state':
+            case this._stateNameState:
                 if (!handledByChildObject) {
                     this.log(models_1.LogLevel.Trace, `Aktor Update für ${this.info.customName} auf ${state.val}`);
                 }
@@ -42,26 +48,35 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
                 break;
         }
     }
+    /** @inheritDoc */
     setActuator(command) {
-        if (this.actuatorOnSwitchID === '') {
-            this.log(models_1.LogLevel.Error, `Keine Switch ID bekannt.`);
+        if (this._actuatorOnStateIdState === '') {
+            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 timeout = newVal && command.isForceAction ? 30 * 60 * 1000 : -1;
-        this.setActuator(new models_1.ActuatorSetStateCommand(command, newVal, 'Due to ZigbeeActuatorToggle', timeout));
+        const setStateCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, command);
+        this.setActuator(setStateCommand);
         return newVal;
     }
+    /** @inheritDoc */
     writeActuatorStateToDevice(c) {
         this.log(models_1.LogLevel.Debug, c.logMessage, services_1.LogDebugType.SetActuator);
-        this.setState(this.actuatorOnSwitchID, c.stateValue, undefined, (err) => {
+        this.setState(this._actuatorOnStateIdState, c.stateValue, undefined, (err) => {
             this.log(models_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
         });
     }

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

@@ -7,3 +7,5 @@ export * from './zigbeeMagnetContact';
 export * from './zigbeeMotionSensor';
 export * from './zigbeeShutter';
 export * from './zigbeeSwitch';
+export { ZigbeeLamp } from './zigbeeLamp';
+export { ZigbeeWindowHandle } from './zigbeeWindowHandle';

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

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeWindowHandle = exports.ZigbeeLamp = void 0;
 __exportStar(require("./ZigbeeActuator"), exports);
 __exportStar(require("./zigbeeDevice"), exports);
 __exportStar(require("./zigbeeDimmer"), exports);
@@ -23,3 +24,7 @@ __exportStar(require("./zigbeeMagnetContact"), exports);
 __exportStar(require("./zigbeeMotionSensor"), exports);
 __exportStar(require("./zigbeeShutter"), exports);
 __exportStar(require("./zigbeeSwitch"), exports);
+var zigbeeLamp_1 = require("./zigbeeLamp");
+Object.defineProperty(exports, "ZigbeeLamp", { enumerable: true, get: function () { return zigbeeLamp_1.ZigbeeLamp; } });
+var zigbeeWindowHandle_1 = require("./zigbeeWindowHandle");
+Object.defineProperty(exports, "ZigbeeWindowHandle", { enumerable: true, get: function () { return zigbeeWindowHandle_1.ZigbeeWindowHandle; } });

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { DeviceType } from '../../deviceType';
 import { IoBrokerBaseDevice } from '../../IoBrokerBaseDevice';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
@@ -6,20 +5,20 @@ import { iDisposable } from '../../../services';
 export declare class ZigbeeDevice extends IoBrokerBaseDevice implements iDisposable {
     protected _available: boolean;
     protected _dontSendOnUnavailable: boolean;
-    protected _debounceStateDelay: number;
-    private _lastWrite;
     private readonly _deviceQueryId;
     get available(): boolean;
     protected _linkQuality: number;
-    readonly persistZigbeeInterval: NodeJS.Timeout;
+    private readonly _persistZigbeeInterval;
     get linkQuality(): number;
     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;
     triggerDeviceQuery(): void;
+    /** @inheritDoc */
     dispose(): void;
     persistZigbeeDevice(): void;
+    /** @inheritDoc */
     protected setState(pointId: string, state: string | number | boolean | ioBroker.State | ioBroker.SettableState | null, onSuccess?: (() => void) | undefined, onError?: ((error: Error) => void) | undefined): void;
 }

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

@@ -18,17 +18,14 @@ class ZigbeeDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
         super(pInfo, pType);
         this._available = false;
         this._dontSendOnUnavailable = false;
-        // If configured > 0, this indicates the minimum time between state writes in ms
-        this._debounceStateDelay = 0;
-        this._lastWrite = 0;
         this._linkQuality = 0;
-        this.persistZigbeeInterval = services_1.Utils.guardedInterval(() => {
+        this._persistZigbeeInterval = services_1.Utils.guardedInterval(() => {
             this.persistZigbeeDevice();
         }, 15 * 60 * 1000, this, false);
         this._lastUpdate = new Date(0);
-        this.stateMap = new Map();
         this._deviceQueryId = `${this.info.fullID}.device_query`;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false, pOverride = false) {
         this.log(models_1.LogLevel.DeepTrace, `Zigbee: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         if (!pOverride) {
@@ -42,7 +39,7 @@ class ZigbeeDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
             case 'available':
                 const newAvailability = state.val;
                 if (this._available && !newAvailability) {
-                    this.log(models_1.LogLevel.Debug, `Device became unavailable.`);
+                    this.log(models_1.LogLevel.Debug, 'Device became unavailable.');
                 }
                 this._available = newAvailability;
                 break;
@@ -63,30 +60,24 @@ class ZigbeeDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
         }
     }
     triggerDeviceQuery() {
-        this.log(models_1.LogLevel.Info, `Triggering Device Query`);
+        this.log(models_1.LogLevel.Info, 'Triggering Device Query');
         this.setState(this._deviceQueryId, true);
     }
+    /** @inheritDoc */
     dispose() {
-        clearInterval(this.persistZigbeeInterval);
+        clearInterval(this._persistZigbeeInterval);
     }
     persistZigbeeDevice() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistZigbeeDevice(this);
     }
+    /** @inheritDoc */
     setState(pointId, state, onSuccess = undefined, onError = undefined) {
         if (this._dontSendOnUnavailable && !this._available) {
             this.log(models_1.LogLevel.Warn, `Device unavailable --> Not changing ${pointId} to ${state}`);
             return;
         }
-        if (this._debounceStateDelay === 0 || services_1.Utils.nowMS() - this._lastWrite > this._debounceStateDelay) {
-            this._lastWrite = services_1.Utils.nowMS();
-            super.setState(pointId, state, onSuccess, onError);
-            return;
-        }
-        services_1.Utils.guardedTimeout(() => {
-            this.log(models_1.LogLevel.Trace, `Debounced write to ${pointId} to ${state}`);
-            this.setState(pointId, state, onSuccess, onError);
-        }, this._debounceStateDelay, this);
+        super.setState(pointId, state, onSuccess, onError);
     }
 }
 exports.ZigbeeDevice = ZigbeeDevice;

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

@@ -1,41 +1,26 @@
-import { ActuatorSetStateCommand, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, DimmerSetLightCommand, DimmerSettings, LampSetTimeBasedCommand, LampToggleLightCommand, RestoreTargetAutomaticValueCommand } from '../../../../models';
+import { DimmerSetLightCommand, DimmerSettings, LampSetTimeBasedCommand } from '../../../../models';
 import { DeviceType } from '../../deviceType';
-import { ZigbeeDevice } from './index';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
 import { iDimmableLamp } from '../../baseDeviceInterfaces/iDimmableLamp';
 import { iTemporaryDisableAutomatic } from '../../baseDeviceInterfaces';
-import { BlockAutomaticHandler } from '../../../services/blockAutomaticHandler';
-export declare abstract class ZigbeeDimmer extends ZigbeeDevice implements iDimmableLamp, iTemporaryDisableAutomatic {
-    readonly blockAutomationHandler: BlockAutomaticHandler;
-    queuedValue: boolean | null;
+import { ZigbeeLamp } from './zigbeeLamp';
+export declare abstract class ZigbeeDimmer extends ZigbeeLamp implements iDimmableLamp, iTemporaryDisableAutomatic {
+    /** @inheritDoc */
     settings: DimmerSettings;
-    targetAutomaticState: boolean;
-    protected _lastPersist: number;
     protected abstract readonly _stateIdBrightness: string;
-    protected abstract readonly _stateIdState: string;
     protected abstract readonly _stateIdTransitionTime: string;
     protected abstract readonly _stateNameBrightness: string;
-    protected abstract readonly _stateNameState: string;
     protected abstract readonly _stateNameTransitionTime: string;
-    protected constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
     protected _brightness: number;
-    get brightness(): number;
-    protected _lightOn: boolean;
-    get lightOn(): boolean;
     protected _transitionTime: number;
-    get transitionTime(): number;
-    get actuatorOn(): boolean;
-    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
+    protected constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
+    get brightness(): number;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
     setTimeBased(c: LampSetTimeBasedCommand): void;
-    setActuator(c: ActuatorSetStateCommand): void;
-    toggleActuator(c: ActuatorToggleCommand): boolean;
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     setLight(c: DimmerSetLightCommand): void;
-    persist(): void;
-    toggleLight(c: LampToggleLightCommand): boolean;
-    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
     private setBrightnessState;
 }

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

@@ -3,50 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeDimmer = void 0;
 const models_1 = require("../../../../models");
 const services_1 = require("../../../services");
-const index_1 = require("./index");
 const DeviceCapability_1 = require("../../DeviceCapability");
-const blockAutomaticHandler_1 = require("../../../services/blockAutomaticHandler");
 const sharedFunctions_1 = require("../../sharedFunctions");
-class ZigbeeDimmer extends index_1.ZigbeeDevice {
+const zigbeeLamp_1 = require("./zigbeeLamp");
+class ZigbeeDimmer extends zigbeeLamp_1.ZigbeeLamp {
     constructor(pInfo, deviceType) {
         super(pInfo, deviceType);
-        this.queuedValue = null;
+        /** @inheritDoc */
         this.settings = new models_1.DimmerSettings();
-        this.targetAutomaticState = false;
-        this._lastPersist = 0;
         this._brightness = 0;
-        this._lightOn = false;
         this._transitionTime = 0;
-        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.dimmablelamp);
-        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.blockAutomatic);
-        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this));
     }
+    /** @inheritDoc */
     get brightness() {
         return this._brightness;
     }
-    get lightOn() {
-        return this._lightOn;
-    }
-    get transitionTime() {
-        return this._transitionTime;
-    }
-    get actuatorOn() {
-        return this.lightOn;
-    }
-    restoreTargetAutomaticValue(c) {
-        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState, 'Restore targetAutomaticState due to BlockAutomaticHandler'));
-    }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         this.queuedValue = null;
         this.log(models_1.LogLevel.DeepTrace, `Dimmer Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         super.update(idSplit, state, initial, true);
         switch (idSplit[3]) {
-            case this._stateNameState:
-                this.log(models_1.LogLevel.Trace, `Dimmer Update für ${this.info.customName} auf ${state.val}`);
-                this._lightOn = state.val;
-                this.persist();
-                break;
             case this._stateNameBrightness:
                 this.log(models_1.LogLevel.Trace, `Dimmer Helligkeit Update für ${this.info.customName} auf ${state.val}`);
                 this._brightness = state.val;
@@ -58,42 +36,45 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
                 break;
         }
     }
+    /** @inheritDoc */
     setTimeBased(c) {
         this.setLight(models_1.DimmerSetLightCommand.byTimeBased(this.settings, c));
     }
-    setActuator(c) {
-        this.setLight(new models_1.DimmerSetLightCommand(c, c.on, '', c.timeout));
-    }
-    toggleActuator(c) {
-        const setActuatorCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, c);
-        this.setActuator(setActuatorCommand);
-        return setActuatorCommand.on;
-    }
-    /**
-     * @inheritDoc
-     */
+    /** @inheritDoc */
     setLight(c) {
         var _a;
-        if (this._stateIdState === '') {
-            this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
+        if (this._actuatorOnStateIdState === '') {
+            this.log(models_1.LogLevel.Error, 'Keine State ID bekannt.');
             return;
         }
         if (!this.ioConn) {
-            this.log(models_1.LogLevel.Error, `Keine Connection bekannt.`);
+            this.log(models_1.LogLevel.Error, 'Keine Connection bekannt.');
             return;
         }
         const dontBlock = sharedFunctions_1.LampUtils.checkUnBlock(this, c);
         if (sharedFunctions_1.LampUtils.checkBlockActive(this, c)) {
             return;
         }
+        if (c.isAutomaticAction) {
+            // Preserve the target state for the automatic handler, as
+            this.targetAutomaticState = c.on;
+        }
+        if (sharedFunctions_1.LampUtils.canDimmerChangeBeSkipped(this, c)) {
+            return;
+        }
         if (c.transitionTime > -1) {
             this.setState(this._stateIdTransitionTime, c.transitionTime);
         }
         if (c.on && c.brightness <= 0 && this.brightness < 10) {
             c.brightness = 10;
         }
-        if (c.timeout > -1 && !dontBlock) {
-            this.blockAutomationHandler.disableAutomatic(c.timeout, models_1.CollisionSolving.overrideIfGreater);
+        if (!dontBlock && c.disableAutomaticCommand !== null) {
+            if (c.disableAutomaticCommand === undefined && c.isForceAction) {
+                c.disableAutomaticCommand = models_1.BlockAutomaticCommand.fromDeviceSettings(c, this.settings);
+            }
+            if (c.disableAutomaticCommand) {
+                this.blockAutomationHandler.disableAutomatic(c.disableAutomaticCommand);
+            }
         }
         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
@@ -108,27 +89,11 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
         }
         this.setBrightnessState(this.settings.turnOnThreshhold, () => {
             services_1.Utils.guardedTimeout(() => {
-                this.log(models_1.LogLevel.Info, `Delayed reduced brightness on ${this.info.customName}`);
+                this.log(models_1.LogLevel.Info, `Delayed reduced brightness on ${this.info.customName} to ${c.brightness} for command: ${c.logMessage}`);
                 this.setBrightnessState(c.brightness);
             }, 1000, this);
         });
     }
-    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;
-    }
-    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/zigbeeHeater.d.ts

@@ -1,17 +1,18 @@
-/// <reference types="node" />
 import { ZigbeeDevice } from './zigbeeDevice';
 import { iBatteryDevice, iHeater } from '../../baseDeviceInterfaces';
 import { HeaterSettings } from '../../../../models';
 import { DeviceType } from '../../deviceType';
 import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
 import { PIDController } from '../../../../liquid-pid';
+import { Battery } from '../../sharedFunctions';
 export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater, iBatteryDevice {
-    protected _battery: number;
-    private _lastBatteryPersist;
-    get lastBatteryPersist(): number;
+    /** @inheritDoc */
+    readonly battery: Battery;
+    /** @inheritDoc */
     readonly persistHeaterInterval: NodeJS.Timeout;
+    /** @inheritDoc */
     settings: HeaterSettings;
-    get battery(): number;
+    protected _battery: number;
     protected _iAutomaticInterval: NodeJS.Timeout | undefined;
     protected _initialSeasonCheckDone: boolean;
     protected _level: number;
@@ -19,28 +20,37 @@ export declare class ZigbeeHeater extends ZigbeeDevice implements iHeater, iBatt
     protected _temperatur: number;
     protected _desiredTemperatur: number;
     protected _pidController: PIDController;
-    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
     protected _seasonTurnOff: boolean;
+    protected _roomTemperature: number;
+    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    /** @inheritDoc */
+    get batteryLevel(): number;
+    /** @inheritDoc */
     get seasonTurnOff(): boolean;
+    /** @inheritDoc */
     set seasonTurnOff(value: boolean);
+    /** @inheritDoc */
     get desiredTemperature(): number;
+    /** @inheritDoc */
     set desiredTemperature(val: number);
-    protected _humidity: number;
-    get humidity(): number;
     get sLevel(): string;
+    /** @inheritDoc */
     get iLevel(): number;
     get sTemperatur(): string;
+    /** @inheritDoc */
     get iTemperature(): number;
-    protected _roomTemperature: number;
+    /** @inheritDoc */
     get roomTemperature(): number;
-    set roomTemperatur(val: number);
+    protected set roomTemperatur(val: number);
+    /** @inheritDoc */
     checkAutomaticChange(): void;
-    stopAutomaticCheck(): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
     persistHeater(): void;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
     protected getNextPidLevel(): number;
     private checkSeasonTurnOff;
-    persistBatteryDevice(): void;
-    dispose(): void;
 }