hoffmation-base 3.0.0-alpha.27 → 3.0.0-alpha.29

package/lib/models/command/baseCommand.js

@@ -14,6 +14,9 @@ class BaseCommand {
         this.timestamp = new Date();
     }
     get isAutomaticAction() {
+        if (this.overrideCommandSource !== undefined) {
+            return this.overrideCommandSource === commandSource_1.CommandSource.Automatic;
+        }
         if (this.source instanceof BaseCommand) {
             return this.source.isAutomaticAction;
         }

package/lib/models/timeCallback.js

@@ -96,8 +96,8 @@ class TimeCallback {
                 }
                 break;
         }
-        if (nextCalculatedTime < now && this.nextToDo && this.nextToDo > now) {
-            server_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, 'Time Callback recalc results in the past, while previous target is still in future --> fire immediately.');
+        if (nextCalculatedTime < now && this.nextToDo && this.nextToDo > this.lastDone) {
+            server_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Time Callback recalc results in the past, while previous target wasn't yet done --> fire immediately.`);
             this.perform(now);
             return;
         }
@@ -110,11 +110,11 @@ class TimeCallback {
     }
     perform(now = new Date()) {
         server_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Timecallback '${this.name}' fired`);
-        this.cFunction();
         this.lastDone = now;
         this.nextToDo = undefined;
         this._calculationSunrise = undefined;
         this._calculationSunset = undefined;
+        this.cFunction();
     }
 }
 exports.TimeCallback = TimeCallback;

package/lib/server/config/heatingMode.d.ts

@@ -1,5 +1,6 @@
 export declare enum HeatingMode {
     None = 0,
     Winter = 1,
-    Sommer = 2
+    Summer = 2,
+    TransitionalSeason = 3
 }

package/lib/server/config/heatingMode.js

@@ -5,5 +5,6 @@ var HeatingMode;
 (function (HeatingMode) {
     HeatingMode[HeatingMode["None"] = 0] = "None";
     HeatingMode[HeatingMode["Winter"] = 1] = "Winter";
-    HeatingMode[HeatingMode["Sommer"] = 2] = "Sommer";
+    HeatingMode[HeatingMode["Summer"] = 2] = "Summer";
+    HeatingMode[HeatingMode["TransitionalSeason"] = 3] = "TransitionalSeason";
 })(HeatingMode || (exports.HeatingMode = HeatingMode = {}));

package/lib/server/devices/espresense/detectedBluetoothDevice.js

@@ -90,7 +90,7 @@ class DetectedBluetoothDevice {
         const dataPoints = this.getDistances(maxAge);
         const result = [`Distances for ${this.info.customName}`];
         for (const data of dataPoints) {
-            result.push(`${data.trackerName}: ${services_1.Utils.round((_a = data.distance) !== null && _a !== void 0 ? _a : -99, 2)}m updated ${new Date(data.lastUpdate).toLocaleTimeString()}`);
+            result.push(`${data.trackerName}: ${services_1.Utils.round((_a = data.distance) !== null && _a !== void 0 ? _a : -99, 2)}m updated ${new Date(data.lastUpdate).toLocaleTimeString('de-DE')}`);
             services_1.Utils.nowTime();
         }
         return result.join('\n');

package/lib/server/devices/groups/windowGroup.js

@@ -79,11 +79,11 @@ class WindowGroup extends base_group_1.BaseGroup {
         });
     }
     sunriseUp(c) {
-        this.windows.forEach((f) => {
-            if (!this.getRoom().settings.sonnenAufgangRollos || f.getShutter().length === 0) {
+        this.windows.forEach((w) => {
+            if (!this.getRoom().settings.sonnenAufgangRollos || w.getShutter().length === 0) {
                 return;
             }
-            f.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(c, 100));
+            w.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(c, 100));
         });
     }
     restoreShutterPosition(c) {
@@ -164,7 +164,7 @@ class WindowGroup extends base_group_1.BaseGroup {
         }
         if (this.sunriseShutterCallback === undefined) {
             this.log(models_1.LogLevel.Debug, `Add Sunrise shutter TimeCallback for ${this.roomName}`);
-            this.sunriseShutterCallback = new models_1.TimeCallback(`${this.roomName} Sonnenaufgang Rollos`, models_1.TimeCallbackType.Sunrise, () => {
+            this.sunriseShutterCallback = new models_1.TimeCallback(`${this.roomName} Sunrise Shutter`, models_1.TimeCallbackType.Sunrise, () => {
                 if (room.skipNextRolloUp) {
                     this.log(models_1.LogLevel.Info, `${this.roomName} skipped sunrise up due to room.skipNextRolloUp`);
                     room.skipNextRolloUp = false;

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

@@ -10,12 +10,12 @@ class LampUtils {
                 var _a, _b;
                 LampUtils.stromStossContinueTimeouts.delete(actuator.id);
                 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.Automatic, true, 'StromStoss On due to Presence'));
+                    actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Automatic, true, 'StromStoss On due to Presence', null));
                 }
             }, actuator.settings.stromStossResendTime * 1000, this));
         }
         services_1.Utils.guardedTimeout(() => {
-            actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Force, false, 'StromStoss Off'));
+            actuator.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Force, false, 'StromStoss Off', null));
         }, 3000, this);
     }
     static setTimeBased(device, c) {
@@ -55,7 +55,7 @@ class LampUtils {
     }
     static checkBlockActive(device, c) {
         if (!c.isForceAction && device.blockAutomationHandler.automaticBlockActive) {
-            device.log(models_1.LogLevel.Debug, `Skip command to ${c.on} as it is locked until ${new Date(device.blockAutomationHandler.automaticBlockedUntil).toLocaleTimeString()}; command Log: ${c.logMessage}`);
+            device.log(models_1.LogLevel.Debug, `Skip command to ${c.on} as it is locked until ${new Date(device.blockAutomationHandler.automaticBlockedUntil).toLocaleTimeString('de-DE')}; command Log: ${c.logMessage}`);
             device.targetAutomaticState = c.on;
             return true;
         }

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

@@ -4,7 +4,7 @@ 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 {
+export declare abstract class ZigbeeActuator extends ZigbeeDevice implements iActuator {
     private _actuatorOn;
     /** @inheritDoc */
     readonly blockAutomationHandler: BlockAutomaticHandler;
@@ -12,12 +12,12 @@ export declare class ZigbeeActuator extends ZigbeeDevice implements iActuator {
     targetAutomaticState: boolean;
     /** @inheritDoc */
     settings: ActuatorSettings;
-    protected readonly actuatorOnSwitchID: string;
+    protected abstract readonly _stateIdState: string;
     /** @inheritDoc */
     queuedValue: boolean | null;
     /** @inheritDoc */
     get actuatorOn(): boolean;
-    constructor(pInfo: IoBrokerDeviceInfo, type: DeviceType, actuatorOnSwitchID: string);
+    constructor(pInfo: IoBrokerDeviceInfo, type: DeviceType);
     /** @inheritDoc */
     restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     /** @inheritDoc */

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

@@ -12,7 +12,7 @@ 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 */
@@ -23,7 +23,6 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
         this.queuedValue = null;
         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));
     }
     /** @inheritDoc */
@@ -49,7 +48,7 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
     }
     /** @inheritDoc */
     setActuator(command) {
-        if (this.actuatorOnSwitchID === '') {
+        if (this._stateIdState === '') {
             this.log(models_1.LogLevel.Error, 'Keine Switch ID bekannt.');
             return;
         }
@@ -70,7 +69,7 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
     /** @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._stateIdState, 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,4 @@ export * from './zigbeeMagnetContact';
 export * from './zigbeeMotionSensor';
 export * from './zigbeeShutter';
 export * from './zigbeeSwitch';
+export { ZigbeeLamp } from './zigbeeLamp';

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.ZigbeeLamp = void 0;
 __exportStar(require("./ZigbeeActuator"), exports);
 __exportStar(require("./zigbeeDevice"), exports);
 __exportStar(require("./zigbeeDimmer"), exports);
@@ -23,3 +24,5 @@ __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; } });

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

@@ -1,53 +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 {
-    /** @inheritDoc */
-    readonly blockAutomationHandler: BlockAutomaticHandler;
-    /** @inheritDoc */
-    queuedValue: boolean | null;
+import { ZigbeeLamp } from './zigbeeLamp';
+export declare abstract class ZigbeeDimmer extends ZigbeeLamp implements iDimmableLamp, iTemporaryDisableAutomatic {
     /** @inheritDoc */
     settings: DimmerSettings;
-    /** @inheritDoc */
-    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;
     /** @inheritDoc */
     get brightness(): number;
-    protected _lightOn: boolean;
-    /** @inheritDoc */
-    get lightOn(): boolean;
     protected _transitionTime: number;
     /** @inheritDoc */
-    get actuatorOn(): boolean;
-    /** @inheritDoc */
-    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
-    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     /** @inheritDoc */
     setTimeBased(c: LampSetTimeBasedCommand): void;
     /** @inheritDoc */
-    setActuator(c: ActuatorSetStateCommand): void;
-    /** @inheritDoc */
-    toggleActuator(c: ActuatorToggleCommand): boolean;
-    /** @inheritDoc */
     setLight(c: DimmerSetLightCommand): void;
-    /** @inheritDoc */
-    persist(): void;
-    /** @inheritDoc */
-    toggleLight(c: LampToggleLightCommand): boolean;
-    /** @inheritDoc */
-    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
     private setBrightnessState;
 }

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

@@ -3,55 +3,30 @@ 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);
         /** @inheritDoc */
-        this.queuedValue = null;
-        /** @inheritDoc */
         this.settings = new models_1.DimmerSettings();
-        /** @inheritDoc */
-        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;
     }
     /** @inheritDoc */
-    get lightOn() {
-        return this._lightOn;
-    }
-    /** @inheritDoc */
-    get actuatorOn() {
-        return this.lightOn;
-    }
-    /** @inheritDoc */
-    restoreTargetAutomaticValue(c) {
-        this.setActuator(new models_1.ActuatorSetStateCommand(c, this.targetAutomaticState));
-    }
-    /** @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;
@@ -68,16 +43,6 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
         this.setLight(models_1.DimmerSetLightCommand.byTimeBased(this.settings, c));
     }
     /** @inheritDoc */
-    setActuator(c) {
-        this.setLight(new models_1.DimmerSetLightCommand(c, c.on, '', c.disableAutomaticCommand));
-    }
-    /** @inheritDoc */
-    toggleActuator(c) {
-        const setActuatorCommand = models_1.ActuatorSetStateCommand.byActuatorAndToggleCommand(this, c);
-        this.setActuator(setActuatorCommand);
-        return setActuatorCommand.on;
-    }
-    /** @inheritDoc */
     setLight(c) {
         var _a;
         if (this._stateIdState === '') {
@@ -124,25 +89,6 @@ class ZigbeeDimmer extends index_1.ZigbeeDevice {
             }, 1000, this);
         });
     }
-    /** @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 */
-    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._stateIdState, c.stateValue);
-    }
     setBrightnessState(brightness, onSuccess) {
         this.setState(this._stateIdBrightness, Math.max(0, Math.min(brightness, 100)), onSuccess);
     }

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

@@ -0,0 +1,20 @@
+import { ZigbeeActuator } from './ZigbeeActuator';
+import { iLamp, iTemporaryDisableAutomatic } from '../../baseDeviceInterfaces';
+import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../../models';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { DeviceType } from '../../deviceType';
+export declare abstract class ZigbeeLamp extends ZigbeeActuator implements iLamp, iTemporaryDisableAutomatic {
+    protected abstract readonly _stateNameState: string;
+    protected _lightOn: boolean;
+    constructor(pInfo: IoBrokerDeviceInfo, deviceType: DeviceType);
+    /** @inheritDoc */
+    get lightOn(): boolean;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    /** @inheritDoc */
+    setTimeBased(c: LampSetTimeBasedCommand): void;
+    /** @inheritdoc */
+    setLight(c: LampSetLightCommand): void;
+    /** @inheritDoc */
+    toggleLight(c: LampToggleLightCommand): boolean;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeLamp = void 0;
+const ZigbeeActuator_1 = require("./ZigbeeActuator");
+const models_1 = require("../../../../models");
+const sharedFunctions_1 = require("../../sharedFunctions");
+const DeviceCapability_1 = require("../../DeviceCapability");
+class ZigbeeLamp extends ZigbeeActuator_1.ZigbeeActuator {
+    constructor(pInfo, deviceType) {
+        super(pInfo, deviceType);
+        this._lightOn = false;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
+    }
+    /** @inheritDoc */
+    get lightOn() {
+        return this._lightOn;
+    }
+    /** @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)}`);
+        }
+        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, `Lamp Update für ${this.info.customName} auf ${state.val}`);
+                this._lightOn = state.val;
+                this.persist();
+                break;
+        }
+    }
+    /** @inheritDoc */
+    setTimeBased(c) {
+        sharedFunctions_1.LampUtils.setTimeBased(this, c);
+    }
+    /** @inheritdoc */
+    setLight(c) {
+        super.setActuator(c);
+    }
+    /** @inheritDoc */
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
+    }
+}
+exports.ZigbeeLamp = ZigbeeLamp;

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

@@ -89,11 +89,11 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
             this._firstCommandRecieved = true;
         }
         else if (this._firstCommandRecieved && c.isInitial) {
-            this.log(models_1.LogLevel.Debug, `Skipped initial Rollo to ${pPosition} as we recieved a command already`);
+            this.log(models_1.LogLevel.Debug, `Skipped initial shutter to ${pPosition} as we recieved a command already`);
             return;
         }
         if (this.currentLevel === pPosition && !c.isForceAction) {
-            this.log(models_1.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one, commandLog: ${c.logMessage}`, services_1.LogDebugType.SkipUnchangedRolloPosition);
+            this.log(models_1.LogLevel.Debug, `Skip shutter command to Position ${pPosition} as this is the current one, commandLog: ${c.logMessage}`, services_1.LogDebugType.SkipUnchangedRolloPosition);
             return;
         }
         this.log(models_1.LogLevel.Debug, c.logMessage);

package/lib/server/devices/zigbee/zigbeeBlitzShp.d.ts

@@ -6,6 +6,7 @@ import { iLoadMeter } from '../baseDeviceInterfaces/iLoadMeter';
 export declare class ZigbeeBlitzShp extends ZigbeeActuator implements iExcessEnergyConsumer, iLoadMeter {
     /** @inheritDoc */
     settings: ActuatorSettings;
+    protected readonly _stateIdState: string;
     private _steckerOn;
     private _current;
     private _energy;

package/lib/server/devices/zigbee/zigbeeBlitzShp.js

@@ -7,7 +7,7 @@ const BaseDevices_1 = require("./BaseDevices");
 const DeviceCapability_1 = require("../DeviceCapability");
 class ZigbeeBlitzShp extends BaseDevices_1.ZigbeeActuator {
     constructor(pInfo) {
-        super(pInfo, deviceType_1.DeviceType.ZigbeeBlitzShp, `${pInfo.fullID}.state`);
+        super(pInfo, deviceType_1.DeviceType.ZigbeeBlitzShp);
         /** @inheritDoc */
         this.settings = new models_1.ActuatorSettings();
         this._steckerOn = false;
@@ -16,6 +16,7 @@ class ZigbeeBlitzShp extends BaseDevices_1.ZigbeeActuator {
         this._loadPower = 0;
         this._availableForExcessEnergy = true;
         this._activatedByExcessEnergy = false;
+        this._stateIdState = `${pInfo.fullID}.state`;
         this.settings.energySettings = new models_1.ExcessEnergyConsumerSettings();
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.excessEnergyConsumer);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.loadMetering);

package/lib/server/devices/zigbee/zigbeeIkeaSteckdose.d.ts

@@ -1,6 +1,7 @@
 import { ZigbeeActuator } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeIkeaSteckdose extends ZigbeeActuator {
+    protected readonly _stateIdState: string;
     constructor(pInfo: IoBrokerDeviceInfo);
     /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;

package/lib/server/devices/zigbee/zigbeeIkeaSteckdose.js

@@ -6,7 +6,8 @@ const BaseDevices_1 = require("./BaseDevices");
 const models_1 = require("../../../models");
 class ZigbeeIkeaSteckdose extends BaseDevices_1.ZigbeeActuator {
     constructor(pInfo) {
-        super(pInfo, deviceType_1.DeviceType.ZigbeeIkeaSteckdose, `${pInfo.fullID}.state`);
+        super(pInfo, deviceType_1.DeviceType.ZigbeeIkeaSteckdose);
+        this._stateIdState = `${pInfo.fullID}.state`;
     }
     /** @inheritDoc */
     update(idSplit, state, initial = false) {

package/lib/server/devices/zigbee/zigbeeIlluActuator.d.ts

@@ -2,7 +2,6 @@ import { ZigbeeActuator } from './BaseDevices';
 import { DeviceType } from '../deviceType';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeIlluActuator extends ZigbeeActuator {
+    protected readonly _stateIdState: string;
     constructor(pInfo: IoBrokerDeviceInfo, deviceType?: DeviceType);
-    /** @inheritDoc */
-    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
 }

package/lib/server/devices/zigbee/zigbeeIlluActuator.js

@@ -2,18 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeIlluActuator = void 0;
 const BaseDevices_1 = require("./BaseDevices");
-const models_1 = require("../../../models");
 const deviceType_1 = require("../deviceType");
 class ZigbeeIlluActuator extends BaseDevices_1.ZigbeeActuator {
     constructor(pInfo, deviceType = deviceType_1.DeviceType.ZigbeeIlluActuator) {
-        super(pInfo, deviceType, `${pInfo.fullID}.state`);
-    }
-    /** @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)}`);
-        }
-        super.update(idSplit, state, initial, true);
+        super(pInfo, deviceType);
+        this._stateIdState = `${pInfo.fullID}.state`;
     }
 }
 exports.ZigbeeIlluActuator = ZigbeeIlluActuator;

package/lib/server/devices/zigbee/zigbeeIlluLampe.d.ts

@@ -1,19 +1,8 @@
-import { ZigbeeIlluActuator } from './zigbeeIlluActuator';
-import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
 import { iLamp } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-export declare class ZigbeeIlluLampe extends ZigbeeIlluActuator implements iLamp {
+import { ZigbeeLamp } from './BaseDevices';
+export declare class ZigbeeIlluLampe extends ZigbeeLamp implements iLamp {
+    protected readonly _stateIdState: string;
+    protected readonly _stateNameState: string;
     constructor(pInfo: IoBrokerDeviceInfo);
-    /** @inheritDoc */
-    get lightOn(): boolean;
-    /** @inheritDoc */
-    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    /** @inheritdoc */
-    setLight(c: LampSetLightCommand): void;
-    /** @inheritDoc */
-    toggleLight(c: LampToggleLightCommand): boolean;
-    /** @inheritDoc */
-    setTimeBased(c: LampSetTimeBasedCommand): void;
-    /** @inheritDoc */
-    persist(): void;
 }

package/lib/server/devices/zigbee/zigbeeIlluLampe.js

@@ -2,45 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeIlluLampe = void 0;
 const deviceType_1 = require("../deviceType");
-const zigbeeIlluActuator_1 = require("./zigbeeIlluActuator");
-const models_1 = require("../../../models");
-const services_1 = require("../../services");
-const DeviceCapability_1 = require("../DeviceCapability");
-const sharedFunctions_1 = require("../sharedFunctions");
-class ZigbeeIlluLampe extends zigbeeIlluActuator_1.ZigbeeIlluActuator {
+const BaseDevices_1 = require("./BaseDevices");
+class ZigbeeIlluLampe extends BaseDevices_1.ZigbeeLamp {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeIlluLampe);
-        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
-    }
-    /** @inheritDoc */
-    get lightOn() {
-        return super.actuatorOn;
-    }
-    /** @inheritDoc */
-    update(idSplit, state, initial = false) {
-        super.update(idSplit, state, initial, true);
-        switch (idSplit[3]) {
-            case 'state':
-                this.log(models_1.LogLevel.Trace, `Lampen Update für ${this.info.customName} auf ${state.val}`);
-                break;
-        }
-    }
-    /** @inheritdoc */
-    setLight(c) {
-        super.setActuator(c);
-    }
-    /** @inheritDoc */
-    toggleLight(c) {
-        return sharedFunctions_1.LampUtils.toggleLight(this, c);
-    }
-    /** @inheritDoc */
-    setTimeBased(c) {
-        sharedFunctions_1.LampUtils.setTimeBased(this, c);
-    }
-    /** @inheritDoc */
-    persist() {
-        var _a;
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        this._stateIdState = `${pInfo.fullID}.state`;
+        this._stateNameState = `${pInfo.fullID}.state`;
     }
 }
 exports.ZigbeeIlluLampe = ZigbeeIlluLampe;

package/lib/server/devices/zigbee/zigbeeUbisysActuator.d.ts

@@ -4,6 +4,7 @@ import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { iLoadMeter } from '../baseDeviceInterfaces/iLoadMeter';
 export declare class ZigbeeUbisysActuator extends ZigbeeActuator implements iLoadMeter {
     private _loadPower;
+    protected readonly _stateIdState: string;
     /**
      * Creates an instance of {@link DeviceType.ZigbeeUbisysActuator} or a derived class like {@link ZigbeeUbisysLampe}
      * @param pInfo - Device creation information
@@ -13,5 +14,5 @@ export declare class ZigbeeUbisysActuator extends ZigbeeActuator implements iLoa
     /** @inheritDoc */
     get loadPower(): number;
     /** @inheritDoc */
-    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
 }

package/lib/server/devices/zigbee/zigbeeUbisysActuator.js

@@ -12,19 +12,17 @@ class ZigbeeUbisysActuator extends BaseDevices_1.ZigbeeActuator {
      * @param deviceType - The device type (if not {@link DeviceType.ZigbeeUbisysActuator})
      */
     constructor(pInfo, deviceType = deviceType_1.DeviceType.ZigbeeUbisysActuator) {
-        super(pInfo, deviceType, `${pInfo.fullID}.state`);
+        super(pInfo, deviceType);
         this._loadPower = 0;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.loadMetering);
+        this._stateIdState = `${pInfo.fullID}.state`;
     }
     /** @inheritDoc */
     get loadPower() {
         return this._loadPower;
     }
     /** @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)}`);
-        }
+    update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'load_power':
                 const newLoadPower = state.val;