hoffmation-base 0.1.38-9 → 0.1.41-1

package/lib/models/deviceSettings/actuatorSettings.d.ts

@@ -3,4 +3,15 @@ export declare class ActuatorSettings extends DeviceSettings {
     dawnOn: boolean;
     duskOn: boolean;
     nightOn: boolean;
+    /**
+     * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
+     * @type {boolean}
+     */
+    isStromStoss: boolean;
+    /**
+     * If this is an Actuator controling a time based relais,
+     * this indicates the time after which we retrigger the relais.
+     * @type {number}
+     */
+    stromStossResendTime: number;
 }

package/lib/models/deviceSettings/actuatorSettings.js

@@ -8,6 +8,17 @@ class ActuatorSettings extends deviceSettings_1.DeviceSettings {
         this.dawnOn = true;
         this.duskOn = true;
         this.nightOn = true;
+        /**
+         * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
+         * @type {boolean}
+         */
+        this.isStromStoss = false;
+        /**
+         * If this is an Actuator controling a time based relais,
+         * this indicates the time after which we retrigger the relais.
+         * @type {number}
+         */
+        this.stromStossResendTime = 180;
     }
 }
 exports.ActuatorSettings = ActuatorSettings;

package/lib/models/persistence/EnergyCalculation.d.ts

@@ -1,8 +1,8 @@
 export declare class EnergyCalculation {
     startMs: number;
-    drawnWattage: number;
-    injectedWattage: number;
-    selfConsumedWattage: number;
+    drawnKwH: number;
+    injectedKwH: number;
+    selfConsumedKwH: number;
     costDrawn: number;
     earnedInjected: number;
     savedSelfConsume: number;

package/lib/models/persistence/EnergyCalculation.js

@@ -4,9 +4,9 @@ exports.EnergyCalculation = void 0;
 class EnergyCalculation {
     constructor(startMs) {
         this.startMs = startMs;
-        this.drawnWattage = 0;
-        this.injectedWattage = 0;
-        this.selfConsumedWattage = 0;
+        this.drawnKwH = 0;
+        this.injectedKwH = 0;
+        this.selfConsumedKwH = 0;
         this.costDrawn = 0;
         this.earnedInjected = 0;
         this.savedSelfConsume = 0;

package/lib/server/devices/groups/lampenGroup.d.ts

@@ -1,6 +1,6 @@
-import { ZigbeeIkeaSteckdose } from '../zigbee/zigbeeIkeaSteckdose';
-import { TimeOfDay } from '../../services/time-callback-service';
-import { ZigbeeIlluLedRGBCCT } from '../zigbee/zigbeeIlluLedRGBCCT';
+import { ZigbeeIkeaSteckdose } from '../zigbee';
+import { TimeOfDay } from '../../services';
+import { ZigbeeIlluLedRGBCCT } from '../zigbee';
 import { BaseGroup } from './base-group';
 import { iLamp } from '../iLamp';
 export declare class LampenGroup extends BaseGroup {

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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LampenGroup = void 0;
-const time_callback_service_1 = require("../../services/time-callback-service");
+const services_1 = require("../../services");
 const base_group_1 = require("./base-group");
 const group_type_1 = require("./group-type");
 const device_cluster_type_1 = require("../device-cluster-type");
 const device_list_1 = require("../device-list");
-const logLevel_1 = require("../../../models/logLevel");
+const models_1 = require("../../../models");
 class LampenGroup extends base_group_1.BaseGroup {
     constructor(roomName, lampenIds = [], steckerIds = [], ledIds = []) {
         super(roomName, group_type_1.GroupType.Light);
@@ -50,21 +50,21 @@ class LampenGroup extends base_group_1.BaseGroup {
         });
     }
     switchTimeConditional(time) {
-        const darkOutside = time_callback_service_1.TimeCallbackService.darkOutsideOrNight(time);
+        const darkOutside = services_1.TimeCallbackService.darkOutsideOrNight(time);
         let resultLampen = false;
         let resultSteckdosen = false;
         if (this.getLED().length > 0) {
-            this.log(logLevel_1.LogLevel.Trace, `Set LEDs time based for time "${time_callback_service_1.TimeOfDay[time]}"`);
+            this.log(models_1.LogLevel.Trace, `Set LEDs time based for time "${services_1.TimeOfDay[time]}"`);
             this.getLED().forEach((s) => {
                 s.setTimeBased(time);
             });
         }
         else if (this.getStecker().length > 0) {
-            this.log(logLevel_1.LogLevel.Trace, `Set outlets time based for time "${time_callback_service_1.TimeOfDay[time]}"`);
+            this.log(models_1.LogLevel.Trace, `Set outlets time based for time "${services_1.TimeOfDay[time]}"`);
             resultSteckdosen = darkOutside;
         }
         else {
-            this.log(logLevel_1.LogLevel.Trace, `Set Lamps time based for time "${time_callback_service_1.TimeOfDay[time]}"`);
+            this.log(models_1.LogLevel.Trace, `Set Lamps time based for time "${services_1.TimeOfDay[time]}"`);
             resultLampen = darkOutside;
         }
         this.setAllLampen(resultLampen, time);
@@ -74,12 +74,12 @@ class LampenGroup extends base_group_1.BaseGroup {
         this.getLampen().forEach((s) => {
             if (!pValue ||
                 time === undefined ||
-                (time === time_callback_service_1.TimeOfDay.Night && s.settings.nightOn) ||
-                (time === time_callback_service_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
-                (time === time_callback_service_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
+                (time === services_1.TimeOfDay.Night && s.settings.nightOn) ||
+                (time === services_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
+                (time === services_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
                 const timeout = pValue && force ? 30 * 60 * 1000 : -1;
                 if (pValue && time !== undefined) {
-                    s.setTimeBased(time);
+                    s.setTimeBased(time, timeout, force);
                 }
                 else {
                     s.setLight(pValue, timeout, force);
@@ -91,9 +91,9 @@ class LampenGroup extends base_group_1.BaseGroup {
         this.getStecker().forEach((s) => {
             if (!pValue ||
                 time === undefined ||
-                (time === time_callback_service_1.TimeOfDay.Night && s.settings.nightOn) ||
-                (time === time_callback_service_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
-                (time === time_callback_service_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
+                (time === services_1.TimeOfDay.Night && s.settings.nightOn) ||
+                (time === services_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
+                (time === services_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
                 const timeout = pValue && force ? 30 * 60 * 1000 : -1;
                 s.setStecker(pValue, timeout, force);
             }

package/lib/server/devices/hmIPDevices/hmIpLampe.d.ts

@@ -1,29 +1,20 @@
 /// <reference types="iobroker" />
 import { HmIPDevice } from './hmIpDevice';
-import { ActuatorSettings } from '../../../models/deviceSettings/actuatorSettings';
+import { ActuatorSettings } from '../../../models';
 import { DeviceInfo } from '../DeviceInfo';
 import { iLamp } from '../iLamp';
-import { TimeOfDay } from '../../services/time-callback-service';
+import { TimeOfDay } from '../../services';
 export declare class HmIpLampe extends HmIPDevice implements iLamp {
     lightOn: boolean;
     queuedLightValue: boolean | null;
-    isStromStoss: boolean;
     settings: ActuatorSettings;
     private lightOnSwitchID;
     private _turnOffTimeout;
     private turnOffTime;
     constructor(pInfo: DeviceInfo);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    /**
-     * This function thats the light to a specific value
-     * @param pValue The desired value
-     * @param timeout A chosen Timeout after which the light should be reset
-     */
+    /** @inheritdoc */
     setLight(pValue: boolean, timeout?: number, force?: boolean): void;
-    /**
-     * Switch the current condition of the light
-     * @param force Whether this is a forcing action skipping delays and locks
-     */
-    toggleLight(force?: boolean): boolean;
-    setTimeBased(time: TimeOfDay): void;
+    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
 }

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

@@ -3,24 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HmIpLampe = void 0;
 const hmIpDevice_1 = require("./hmIpDevice");
 const deviceType_1 = require("../deviceType");
-const utils_1 = require("../../services/utils/utils");
-const actuatorSettings_1 = require("../../../models/deviceSettings/actuatorSettings");
-const logLevel_1 = require("../../../models/logLevel");
-const time_callback_service_1 = require("../../services/time-callback-service");
+const services_1 = require("../../services");
+const models_1 = require("../../../models");
+const models_2 = require("../../../models");
+const services_2 = require("../../services");
 class HmIpLampe extends hmIpDevice_1.HmIPDevice {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.HmIpLampe);
         this.lightOn = false;
         this.queuedLightValue = null;
-        this.isStromStoss = false;
-        this.settings = new actuatorSettings_1.ActuatorSettings();
+        this.settings = new models_1.ActuatorSettings();
         this.lightOnSwitchID = '';
         this._turnOffTimeout = undefined;
         this.turnOffTime = 0;
         this.lightOnSwitchID = `${this.info.fullID}.2.STATE`;
     }
     update(idSplit, state, initial = false) {
-        this.log(logLevel_1.LogLevel.DeepTrace, `Lampen Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        this.log(models_2.LogLevel.DeepTrace, `Lampen Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
         super.update(idSplit, state, initial, true);
         this.queuedLightValue = null;
         switch (idSplit[3]) {
@@ -31,31 +30,33 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
                 break;
         }
     }
-    /**
-     * This function thats the light to a specific value
-     * @param pValue The desired value
-     * @param timeout A chosen Timeout after which the light should be reset
-     */
+    /** @inheritdoc */
     setLight(pValue, timeout = -1, force = false) {
         if (!force && pValue === this.lightOn && this.queuedLightValue === null) {
-            this.log(logLevel_1.LogLevel.DeepTrace, `Skip light command as it is already ${pValue}`);
+            this.log(models_2.LogLevel.DeepTrace, `Skip light command as it is already ${pValue}`);
             return;
         }
         if (this.lightOnSwitchID === '') {
-            this.log(logLevel_1.LogLevel.Error, `Keine Switch ID bekannt.`);
+            this.log(models_2.LogLevel.Error, `Keine Switch ID bekannt.`);
             return;
         }
-        if (!force && utils_1.Utils.nowMS() < this.turnOffTime) {
-            this.log(logLevel_1.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleString()}`);
+        if (!force && services_1.Utils.nowMS() < this.turnOffTime) {
+            this.log(models_2.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleString()}`);
             return;
         }
-        this.log(logLevel_1.LogLevel.Debug, `Lampe schalten Wert: ${pValue}`);
+        this.log(models_2.LogLevel.Debug, `Lampe schalten Wert: ${pValue}`);
         this.setState(this.lightOnSwitchID, pValue, undefined, (err) => {
-            this.log(logLevel_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
+            this.log(models_2.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
         });
         this.queuedLightValue = pValue;
-        if (this.isStromStoss) {
-            timeout = 5000;
+        if (this.settings.isStromStoss) {
+            timeout = 3000;
+            services_1.Utils.guardedTimeout(() => {
+                var _a;
+                if (this.room && ((_a = this.room.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.anyPresent())) {
+                    this.setLight(true, -1, true);
+                }
+            }, this.settings.stromStossResendTime * 1000, this);
         }
         if (this._turnOffTimeout !== undefined) {
             clearTimeout(this._turnOffTimeout);
@@ -64,9 +65,9 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
         if (timeout < 0 || !pValue) {
             return;
         }
-        this.turnOffTime = utils_1.Utils.nowMS() + timeout;
-        this._turnOffTimeout = utils_1.Utils.guardedTimeout(() => {
-            this.log(logLevel_1.LogLevel.Debug, `Delayed Turnoff initiated`);
+        this.turnOffTime = services_1.Utils.nowMS() + timeout;
+        this._turnOffTimeout = services_1.Utils.guardedTimeout(() => {
+            this.log(models_2.LogLevel.Debug, `Delayed Turnoff initiated`);
             this._turnOffTimeout = undefined;
             if (!this.room) {
                 this.setLight(false, -1, true);
@@ -76,21 +77,25 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
             }
         }, timeout, this);
     }
-    /**
-     * Switch the current condition of the light
-     * @param force Whether this is a forcing action skipping delays and locks
-     */
-    toggleLight(force = false) {
+    toggleLight(time, force = false, calculateTime = false) {
+        var _a;
         const newVal = this.queuedLightValue !== null ? !this.queuedLightValue : !this.lightOn;
         const timeout = newVal && force ? 30 * 60 * 1000 : -1;
+        if (newVal && time === undefined && calculateTime && this.room !== undefined) {
+            time = services_2.TimeCallbackService.dayType((_a = this.room) === null || _a === void 0 ? void 0 : _a.settings.lampOffset);
+        }
+        if (newVal && time !== undefined) {
+            this.setTimeBased(time, timeout, force);
+            return true;
+        }
         this.setLight(newVal, timeout, force);
         return newVal;
     }
-    setTimeBased(time) {
-        if ((time === time_callback_service_1.TimeOfDay.Night && this.settings.nightOn) ||
-            (time === time_callback_service_1.TimeOfDay.BeforeSunrise && this.settings.dawnOn) ||
-            (time === time_callback_service_1.TimeOfDay.AfterSunset && this.settings.duskOn)) {
-            this.setLight(true);
+    setTimeBased(time, timeout = -1, force = false) {
+        if ((time === services_2.TimeOfDay.Night && this.settings.nightOn) ||
+            (time === services_2.TimeOfDay.BeforeSunrise && this.settings.dawnOn) ||
+            (time === services_2.TimeOfDay.AfterSunset && this.settings.duskOn)) {
+            this.setLight(true, timeout, force);
         }
     }
 }

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

@@ -6,6 +6,9 @@ export interface iEnergyManager extends IoBrokerBaseDevice {
     excessEnergy: number;
     excessEnergyConsumerConsumption: number;
     totalConsumption: number;
+    drawingWattage: number;
+    selfConsumingWattage: number;
+    injectingWattage: number;
     addExcessConsumer(device: iExcessEnergyConsumer): void;
     recalculatePowerSharing(): void;
     cleanup(): void;

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

@@ -1,11 +1,18 @@
-import { ActuatorSettings } from '../../models/deviceSettings/actuatorSettings';
-import { RoomBase } from '../../models/rooms/RoomBase';
-import { TimeOfDay } from '../services/time-callback-service';
+import { ActuatorSettings } from '../../models';
+import { RoomBase } from '../../models';
+import { TimeOfDay } from '../services';
 import { IoBrokerBaseDevice } from './IoBrokerBaseDevice';
 export interface iLamp extends IoBrokerBaseDevice {
     settings: ActuatorSettings;
     lightOn: boolean;
     room: RoomBase | undefined;
-    setTimeBased(time: TimeOfDay): void;
+    setTimeBased(time: TimeOfDay, timeout: number, force: boolean): void;
+    toggleLight(time: TimeOfDay, force: boolean, calculateTime: boolean): void;
+    /**
+     * This function sets the light to a specific value
+     * @param pValue The desired value
+     * @param timeout A chosen Timeout after which the light should be reset
+     * @param force Wether it is a action based on a user action, to override certain rules
+     */
     setLight(pValue: boolean, timeout: number, force: boolean): void;
 }

package/lib/server/devices/jsObject/jsObjectEnergyManager.d.ts

@@ -4,10 +4,25 @@ import { iEnergyManager } from '../iEnergyManager';
 import { iExcessEnergyConsumer } from '../iExcessEnergyConsumer';
 import { DeviceInfo } from '../DeviceInfo';
 export declare class JsObjectEnergyManager extends IoBrokerBaseDevice implements iEnergyManager {
+    /**
+     * Example:
+     * ________________________________________
+     * | ExcessEnergy | 500W  | -500W | -500W |
+     * | Production   | 1500W | 500W  | 0W    |
+     * _______________________________________
+     * | Consumption  | 1000W | 1000W | 500W  |
+     * | Injecting    | 500W  | 0W    | 0W    |
+     * | drawing      |    0W | 500W  | 500W  |
+     * | selfConsume  | 1000W | 500W  | 0W    |
+     * ________________________________________
+     **/
     get excessEnergyConsumerConsumption(): number;
     get excessEnergy(): number;
     get baseConsumption(): number;
     get totalConsumption(): number;
+    get injectingWattage(): number;
+    get drawingWattage(): number;
+    get selfConsumingWattage(): number;
     get currentProduction(): number;
     private _currentProduction;
     private _excessEnergy;

package/lib/server/devices/jsObject/jsObjectEnergyManager.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsObjectEnergyManager = void 0;
 const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
 const deviceType_1 = require("../deviceType");
-const logLevel_1 = require("../../../models/logLevel");
-const utils_1 = require("../../services/utils/utils");
+const models_1 = require("../../../models");
+const services_1 = require("../../services");
 const index_1 = require("../../../index");
 class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     constructor(info) {
@@ -14,13 +14,25 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
         this._excessEnergyConsumerConsumption = 0;
         this._excessEnergyConsumer = [];
         this._iDatabaseLoggerInterval = null;
-        this._lastPersistenceCalculation = utils_1.Utils.nowMS();
-        this.log(logLevel_1.LogLevel.Info, `Creating Energy Manager Device`);
-        this._iDatabaseLoggerInterval = utils_1.Utils.guardedInterval(() => {
+        this._lastPersistenceCalculation = services_1.Utils.nowMS();
+        this.log(models_1.LogLevel.Info, `Creating Energy Manager Device`);
+        this._iDatabaseLoggerInterval = services_1.Utils.guardedInterval(() => {
             this.persist();
         }, 15 * 60 * 1000, this);
-        this._nextPersistEntry = new index_1.EnergyCalculation(utils_1.Utils.nowMS());
+        this._nextPersistEntry = new index_1.EnergyCalculation(services_1.Utils.nowMS());
     }
+    /**
+     * Example:
+     * ________________________________________
+     * | ExcessEnergy | 500W  | -500W | -500W |
+     * | Production   | 1500W | 500W  | 0W    |
+     * _______________________________________
+     * | Consumption  | 1000W | 1000W | 500W  |
+     * | Injecting    | 500W  | 0W    | 0W    |
+     * | drawing      |    0W | 500W  | 500W  |
+     * | selfConsume  | 1000W | 500W  | 0W    |
+     * ________________________________________
+     **/
     get excessEnergyConsumerConsumption() {
         return this._excessEnergyConsumerConsumption;
     }
@@ -33,6 +45,15 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     get totalConsumption() {
         return this._currentProduction - this._excessEnergy;
     }
+    get injectingWattage() {
+        return Math.max(this._excessEnergy, 0);
+    }
+    get drawingWattage() {
+        return Math.min(this._excessEnergy, 0) * -1;
+    }
+    get selfConsumingWattage() {
+        return Math.min(this.totalConsumption, this._currentProduction);
+    }
     get currentProduction() {
         return this._currentProduction;
     }
@@ -49,14 +70,14 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
         // TODO Implement
     }
     update(idSplit, state, initial, pOverride = false) {
-        this.log(logLevel_1.LogLevel.DeepTrace, `EnergyManager: ${initial ? 'Initial ' : ''} update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}, override: ${pOverride}`);
+        this.log(models_1.LogLevel.DeepTrace, `EnergyManager: ${initial ? 'Initial ' : ''} update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}, override: ${pOverride}`);
         switch (idSplit[3]) {
             case 'CurrentExcessEnergy':
-                this.log(logLevel_1.LogLevel.Trace, `Current excess energy update to ${state.val}`);
+                this.log(models_1.LogLevel.Trace, `Current excess energy update to ${state.val}`);
                 this.setExcessEnergy(state.val);
                 break;
             case 'CurrentProduction':
-                this.log(logLevel_1.LogLevel.Trace, `Current Production Update to ${state.val}`);
+                this.log(models_1.LogLevel.Trace, `Current Production Update to ${state.val}`);
                 this._currentProduction = state.val;
                 break;
         }
@@ -67,34 +88,30 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
         this.recalculatePowerSharing();
     }
     calculatePersistenceValues() {
-        const now = utils_1.Utils.nowMS();
+        const now = services_1.Utils.nowMS();
         const duration = now - this._lastPersistenceCalculation;
-        if (this.excessEnergy < 0) {
-            this._nextPersistEntry.drawnWattage += utils_1.Utils.kWh(this.excessEnergy * -1, duration);
-        }
-        else {
-            this._nextPersistEntry.injectedWattage += utils_1.Utils.kWh(this.excessEnergy, duration);
-            this._nextPersistEntry.selfConsumedWattage += utils_1.Utils.kWh(this.totalConsumption, duration);
-        }
+        this._nextPersistEntry.drawnKwH += services_1.Utils.kWh(this.drawingWattage, duration);
+        this._nextPersistEntry.injectedKwH += services_1.Utils.kWh(this.injectingWattage, duration);
+        this._nextPersistEntry.selfConsumedKwH += services_1.Utils.kWh(this.selfConsumingWattage, duration);
         this._lastPersistenceCalculation = now;
     }
     persist() {
         var _a;
         const obj = JSON.parse(JSON.stringify(this._nextPersistEntry));
-        if (obj.drawnWattage === 0 && obj.injectedWattage === 0 && obj.selfConsumedWattage === 0) {
-            this.log(logLevel_1.LogLevel.Warn, `Not persisting energy Data, as all values are 0.`);
+        if (obj.drawnKwH === 0 && obj.injectedKwH === 0 && obj.selfConsumedKwH === 0) {
+            this.log(models_1.LogLevel.Warn, `Not persisting energy Data, as all values are 0.`);
             return;
         }
         this._nextPersistEntry = new index_1.EnergyCalculation(this._lastPersistenceCalculation);
         obj.endMs = this._lastPersistenceCalculation;
-        obj.earnedInjected = utils_1.Utils.round(obj.injectedWattage * ((_a = index_1.SettingsService.settings.injectWattagePrice) !== null && _a !== void 0 ? _a : 0.06), 4);
-        obj.savedSelfConsume = utils_1.Utils.round(obj.selfConsumedWattage * index_1.SettingsService.settings.wattagePrice, 4);
-        obj.costDrawn = utils_1.Utils.round(obj.selfConsumedWattage * index_1.SettingsService.settings.wattagePrice, 4);
-        obj.injectedWattage = utils_1.Utils.round(obj.injectedWattage, 4);
-        obj.selfConsumedWattage = utils_1.Utils.round(obj.selfConsumedWattage, 4);
-        obj.drawnWattage = utils_1.Utils.round(obj.drawnWattage, 4);
+        obj.earnedInjected = services_1.Utils.round(obj.injectedKwH * ((_a = index_1.SettingsService.settings.injectWattagePrice) !== null && _a !== void 0 ? _a : 0.06), 4);
+        obj.savedSelfConsume = services_1.Utils.round(obj.selfConsumedKwH * index_1.SettingsService.settings.wattagePrice, 4);
+        obj.costDrawn = services_1.Utils.round(obj.drawnKwH * index_1.SettingsService.settings.wattagePrice, 4);
+        obj.injectedKwH = services_1.Utils.round(obj.injectedKwH, 4);
+        obj.selfConsumedKwH = services_1.Utils.round(obj.selfConsumedKwH, 4);
+        obj.drawnKwH = services_1.Utils.round(obj.drawnKwH, 4);
         index_1.dbo === null || index_1.dbo === void 0 ? void 0 : index_1.dbo.persistEnergyManager(obj);
-        this.log(logLevel_1.LogLevel.Info, `Persisting energy Manager Data.`);
+        this.log(models_1.LogLevel.Info, `Persisting energy Manager Data.`);
     }
 }
 exports.JsObjectEnergyManager = JsObjectEnergyManager;

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

@@ -18,6 +18,11 @@ export declare class ZigbeeIlluDimmer extends ZigbeeDevice implements iLamp {
     constructor(pInfo: DeviceInfo);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    /**
+     * @inheritDoc
+     * @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;
     toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
 }

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

@@ -59,6 +59,11 @@ class ZigbeeIlluDimmer extends zigbeeDevice_1.ZigbeeDevice {
                 break;
         }
     }
+    /**
+     * @inheritDoc
+     * @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) {
         if (this.stateID === '') {
             this.log(logLevel_1.LogLevel.Error, `Keine State ID bekannt.`);

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

@@ -2,12 +2,13 @@
 import { DeviceInfo } from '../DeviceInfo';
 import { ZigbeeIlluActuator } from './zigbeeIlluActuator';
 import { iLamp } from '../iLamp';
-import { TimeOfDay } from '../../services/time-callback-service';
+import { TimeOfDay } from '../../services';
 export declare class ZigbeeIlluLampe extends ZigbeeIlluActuator implements iLamp {
     get lightOn(): boolean;
     constructor(pInfo: DeviceInfo);
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritdoc */
     setLight(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleLight(force?: boolean): boolean;
-    setTimeBased(time: TimeOfDay): void;
+    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
 }

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

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeIlluLampe = void 0;
 const deviceType_1 = require("../deviceType");
 const zigbeeIlluActuator_1 = require("./zigbeeIlluActuator");
-const logLevel_1 = require("../../../models/logLevel");
-const time_callback_service_1 = require("../../services/time-callback-service");
+const models_1 = require("../../../models");
+const services_1 = require("../../services");
+const services_2 = require("../../services");
 class ZigbeeIlluLampe extends zigbeeIlluActuator_1.ZigbeeIlluActuator {
     get lightOn() {
         return super.actuatorOn;
@@ -16,22 +17,43 @@ class ZigbeeIlluLampe extends zigbeeIlluActuator_1.ZigbeeIlluActuator {
         super.update(idSplit, state, initial, true);
         switch (idSplit[3]) {
             case 'state':
-                this.log(logLevel_1.LogLevel.Trace, `Lampen Update für ${this.info.customName} auf ${state.val}`);
+                this.log(models_1.LogLevel.Trace, `Lampen Update für ${this.info.customName} auf ${state.val}`);
                 break;
         }
     }
+    /** @inheritdoc */
     setLight(pValue, timeout = -1, force = false) {
-        this.log(logLevel_1.LogLevel.Debug, `Lampenaktor schalten Wert: ${pValue}`);
+        this.log(models_1.LogLevel.Debug, `Lampenaktor schalten Wert: ${pValue}`);
+        if (this.settings.isStromStoss) {
+            timeout = 3000;
+            services_2.Utils.guardedTimeout(() => {
+                var _a;
+                if (this.room && ((_a = this.room.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.anyPresent())) {
+                    this.setLight(true, -1, true);
+                }
+            }, this.settings.stromStossResendTime * 1000, this);
+        }
         super.setActuator(pValue, timeout, force);
     }
-    toggleLight(force = false) {
-        return super.toggleActuator(force);
+    toggleLight(time, force = false, calculateTime = false) {
+        var _a;
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this.lightOn;
+        const timeout = newVal && force ? 30 * 60 * 1000 : -1;
+        if (newVal && time === undefined && calculateTime && this.room !== undefined) {
+            time = services_1.TimeCallbackService.dayType((_a = this.room) === null || _a === void 0 ? void 0 : _a.settings.lampOffset);
+        }
+        if (newVal && time !== undefined) {
+            this.setTimeBased(time, timeout, force);
+            return true;
+        }
+        this.setLight(newVal, timeout, force);
+        return newVal;
     }
-    setTimeBased(time) {
-        if ((time === time_callback_service_1.TimeOfDay.Night && this.settings.nightOn) ||
-            (time === time_callback_service_1.TimeOfDay.BeforeSunrise && this.settings.dawnOn) ||
-            (time === time_callback_service_1.TimeOfDay.AfterSunset && this.settings.duskOn)) {
-            this.setLight(true);
+    setTimeBased(time, timeout = -1, force = false) {
+        if ((time === services_1.TimeOfDay.Night && this.settings.nightOn) ||
+            (time === services_1.TimeOfDay.BeforeSunrise && this.settings.dawnOn) ||
+            (time === services_1.TimeOfDay.AfterSunset && this.settings.duskOn)) {
+            this.setLight(true, timeout, force);
         }
     }
 }