hoffmation-base 0.1.39 → 0.1.41-10

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/deviceSettings/shutterSettings.d.ts

@@ -2,4 +2,10 @@ import { DeviceSettings } from './deviceSettings';
 export declare class ShutterSettings extends DeviceSettings {
     msTilTop: number;
     msTilBot: number;
+    /**
+     * Some shutter give no position feedback on their own, so by knowing the durations in either direction,
+     * we can programmatically trigger the callbacks.
+     * @type {boolean}
+     */
+    triggerPositionUpdateByTime: boolean;
 }

package/lib/models/deviceSettings/shutterSettings.js

@@ -7,6 +7,12 @@ class ShutterSettings extends deviceSettings_1.DeviceSettings {
         super(...arguments);
         this.msTilTop = -1;
         this.msTilBot = -1;
+        /**
+         * Some shutter give no position feedback on their own, so by knowing the durations in either direction,
+         * we can programmatically trigger the callbacks.
+         * @type {boolean}
+         */
+        this.triggerPositionUpdateByTime = false;
     }
 }
 exports.ShutterSettings = ShutterSettings;

package/lib/models/rooms/RoomSettings/RoomSettings.js

@@ -76,6 +76,7 @@ class RoomSettings {
     }
     set sonnenUntergangRolloDelay(value) {
         this._sonnenUntergangRolloDelay = value;
+        this.recalcRolloOffset();
     }
     get movementResetTimer() {
         return this._movementResetTimer;

package/lib/models/timeCallback.js

@@ -42,7 +42,7 @@ class TimeCallback {
             case TimeCallbackType.Sunrise:
                 let fixedSRDate = new Date(time_callback_service_1.TimeCallbackService.nextSunRise.getTime() + this.minuteOffset * 60 * 1000);
                 if (this.sunTimeOffset) {
-                    const nextMinSR = this.sunTimeOffset.getNextMinimumSunrise();
+                    const nextMinSR = this.sunTimeOffset.getNextMinimumSunrise(now);
                     if (nextMinSR > fixedSRDate && fixedSRDate.getDate() === nextMinSR.getDate()) {
                         fixedSRDate = nextMinSR;
                     }
@@ -56,7 +56,7 @@ class TimeCallback {
             case TimeCallbackType.SunSet:
                 let fixedSSDate = new Date(time_callback_service_1.TimeCallbackService.nextSunSet.getTime() + this.minuteOffset * 60 * 1000);
                 if (this.sunTimeOffset) {
-                    const nextMaxSS = this.sunTimeOffset.getNextMaximumSunset();
+                    const nextMaxSS = this.sunTimeOffset.getNextMaximumSunset(now);
                     if (nextMaxSS < fixedSSDate && fixedSSDate.getDate() === nextMaxSS.getDate()) {
                         fixedSSDate = nextMaxSS;
                     }

package/lib/server/devices/device-cluster.d.ts

@@ -1,7 +1,7 @@
 import { DeviceClusterType } from './device-cluster-type';
 import { DeviceList } from './device-list';
 import { IoBrokerBaseDevice } from './IoBrokerBaseDevice';
-import { OwnSonosDevice } from '../services/Sonos/sonos-service';
+import { OwnSonosDevice } from '../services';
 export declare class DeviceCluster {
     deviceMap: Map<DeviceClusterType, DeviceList>;
     constructor(deviceMap?: Map<DeviceClusterType, DeviceList>);

package/lib/server/devices/device-cluster.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceCluster = void 0;
 const device_cluster_type_1 = require("./device-cluster-type");
 const device_list_1 = require("./device-list");
-const utils_1 = require("../services/utils/utils");
+const services_1 = require("../services");
 const lodash_1 = __importDefault(require("lodash"));
 const deviceType_1 = require("./deviceType");
 class DeviceCluster {
@@ -39,6 +39,7 @@ class DeviceCluster {
                 break;
             case deviceType_1.DeviceType.HmIpRoll:
             case deviceType_1.DeviceType.ZigbeeIlluShutter:
+            case deviceType_1.DeviceType.ZigbeeUbisysShutter:
                 clusterTypes.push(device_cluster_type_1.DeviceClusterType.Shutter);
                 break;
             case deviceType_1.DeviceType.ZigbeeSonoffTemp:
@@ -109,7 +110,7 @@ class DeviceCluster {
         }
     }
     toJSON() {
-        const result = utils_1.Utils.jsonFilter(this);
+        const result = services_1.Utils.jsonFilter(this);
         result.deviceDict = Object.fromEntries(this.deviceMap);
         return lodash_1.default.omit(result, [`deviceMap`]);
     }

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

@@ -29,6 +29,7 @@ export declare enum DeviceType {
     ZigbeeAqaraMagnetContact = 215,
     ZigbeeSonoffTemp = 216,
     ZigbeeAqaraOpple3Switch = 217,
+    ZigbeeUbisysShutter = 218,
     JsEnergyManager = 301,
     Wled = 1001
 }

package/lib/server/devices/deviceType.js

@@ -33,6 +33,7 @@ var DeviceType;
     DeviceType[DeviceType["ZigbeeAqaraMagnetContact"] = 215] = "ZigbeeAqaraMagnetContact";
     DeviceType[DeviceType["ZigbeeSonoffTemp"] = 216] = "ZigbeeSonoffTemp";
     DeviceType[DeviceType["ZigbeeAqaraOpple3Switch"] = 217] = "ZigbeeAqaraOpple3Switch";
+    DeviceType[DeviceType["ZigbeeUbisysShutter"] = 218] = "ZigbeeUbisysShutter";
     DeviceType[DeviceType["JsEnergyManager"] = 301] = "JsEnergyManager";
     DeviceType[DeviceType["Wled"] = 1001] = "Wled";
 })(DeviceType = exports.DeviceType || (exports.DeviceType = {}));

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

@@ -1,6 +1,5 @@
-import { deviceConfig } from '../../models/deviceConfig';
+import { deviceConfig, iRoomImportEnforcer } from '../../models';
 import { IoBrokerBaseDevice } from './IoBrokerBaseDevice';
-import { iRoomImportEnforcer } from '../../models/rooms/iRoomImportEnforcer';
 import { iEnergyManager } from './iEnergyManager';
 export declare class Devices {
     static IDENTIFIER_HOMEMATIC: string;
@@ -15,8 +14,8 @@ export declare class Devices {
     }, pRoomImportEnforcer?: iRoomImportEnforcer);
     static midnightReset(): void;
     static resetPraesenzCount(): void;
-    private processZigbeeDevice;
-    private processHMIPDevice;
     static getBatteryInfo(): string;
-    private createEnergyManager;
+    private static processZigbeeDevice;
+    private static processHMIPDevice;
+    private static createEnergyManager;
 }

package/lib/server/devices/devices.js

@@ -1,46 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Devices = void 0;
-const hmIpDevice_1 = require("./hmIPDevices/hmIpDevice");
-const zigbeeDevice_1 = require("./zigbee/zigbeeDevice");
+const models_1 = require("../../models");
+const hmIPDevices_1 = require("./hmIPDevices");
+const zigbee_1 = require("./zigbee");
 const deviceType_1 = require("./deviceType");
-const hmIpPraezenz_1 = require("./hmIPDevices/hmIpPraezenz");
-const log_service_1 = require("../services/log-service/log-service");
+const services_1 = require("../services");
 const DeviceInfo_1 = require("./DeviceInfo");
-const logLevel_1 = require("../../models/logLevel");
-const hmIpBewegung_1 = require("./hmIPDevices/hmIpBewegung");
-const zigbeeAquaraVibra_1 = require("./zigbee/zigbeeAquaraVibra");
-const zigbeeAquaraMotion_1 = require("./zigbee/zigbeeAquaraMotion");
-const zigbeeIkeaSteckdose_1 = require("./zigbee/zigbeeIkeaSteckdose");
-const zigbeeIlluLedRGBCCT_1 = require("./zigbee/zigbeeIlluLedRGBCCT");
-const zigbeeIlluDimmer_1 = require("./zigbee/zigbeeIlluDimmer");
-const zigbeeHeimanSmoke_1 = require("./zigbee/zigbeeHeimanSmoke");
-const zigbeeAquaraWater_1 = require("./zigbee/zigbeeAquaraWater");
-const zigbeeBlitzShp_1 = require("./zigbee/zigbeeBlitzShp");
-const zigbeeIlluLampe_1 = require("./zigbee/zigbeeIlluLampe");
-const zigbeeIlluActuator_1 = require("./zigbee/zigbeeIlluActuator");
-const hmIpLampe_1 = require("./hmIPDevices/hmIpLampe");
-const hmIpRoll_1 = require("./hmIPDevices/hmIpRoll");
-const hmIpTaster_1 = require("./hmIPDevices/hmIpTaster");
-const hmIpWippe_1 = require("./hmIPDevices/hmIpWippe");
-const hmIpGriff_1 = require("./hmIPDevices/hmIpGriff");
-const hmIpTherm_1 = require("./hmIPDevices/hmIpTherm");
-const hmIpHeizung_1 = require("./hmIPDevices/hmIpHeizung");
-const hmIpTuer_1 = require("./hmIPDevices/hmIpTuer");
-const hmIpHeizgruppe_1 = require("./hmIPDevices/hmIpHeizgruppe");
-const zigbeeIlluShutter_1 = require("./zigbee/zigbeeIlluShutter");
-const zigbeeSMaBiTMagnetContact_1 = require("./zigbee/zigbeeSMaBiTMagnetContact");
-const zigbeeSonoffMotion_1 = require("./zigbee/zigbeeSonoffMotion");
-const hmIpAccessPoint_1 = require("./hmIPDevices/hmIpAccessPoint");
-const zigbeeAqaraMagnetContact_1 = require("./zigbee/zigbeeAqaraMagnetContact");
-const zigbeeSonoffTemp_1 = require("./zigbee/zigbeeSonoffTemp");
-const zigbeeAqaraOpple3Switch_1 = require("./zigbee/zigbeeAqaraOpple3Switch");
-const jsObjectEnergyManager_1 = require("./jsObject/jsObjectEnergyManager");
+const jsObject_1 = require("./jsObject");
+const zigbeeUbisysShutter_1 = require("./zigbee/zigbeeUbisysShutter");
 class Devices {
     constructor(pDeviceData, pRoomImportEnforcer) {
         // This forces import of rooms at correct timing, to allow devices to land in proper rooms.
         pRoomImportEnforcer === null || pRoomImportEnforcer === void 0 ? void 0 : pRoomImportEnforcer.addRoomConstructor();
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Constructing devices now`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Constructing devices now`);
         for (const cID in pDeviceData) {
             const cDevConf = pDeviceData[cID];
             if (!cDevConf.common ||
@@ -52,182 +25,185 @@ class Devices {
             }
             const cName = cDevConf.common.name;
             if (cName.indexOf('00-HmIP') === 0) {
-                this.processHMIPDevice(cDevConf);
+                Devices.processHMIPDevice(cDevConf);
             }
             else if (cName.indexOf('00-Zigbee') === 0) {
-                this.processZigbeeDevice(cDevConf);
+                Devices.processZigbeeDevice(cDevConf);
             }
             else if (cName.indexOf('00-EnergyManager') === 0) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Found Energy-Manager in Device json.`);
-                this.createEnergyManager(cDevConf);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Found Energy-Manager in Device json.`);
+                Devices.createEnergyManager(cDevConf);
             }
         }
-        hmIpDevice_1.HmIPDevice.checkMissing();
-        zigbeeDevice_1.ZigbeeDevice.checkMissing();
+        hmIPDevices_1.HmIPDevice.checkMissing();
+        zigbee_1.ZigbeeDevice.checkMissing();
     }
     static midnightReset() {
         // Nothing yet
     }
     static resetPraesenzCount() {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `3 Uhr Reset der Präsenzmelder`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `3 Uhr Reset der Präsenzmelder`);
         for (const dID in Devices.alLDevices) {
             const d = Devices.alLDevices[dID];
             if (d.deviceType === deviceType_1.DeviceType.HmIpPraezenz) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
                 d.detectionsToday = 0;
             }
             else if (d.deviceType === deviceType_1.DeviceType.HmIpBewegung) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
                 d.detectionsToday = 0;
             }
             else if (d.deviceType === deviceType_1.DeviceType.ZigbeeSonoffMotion || d.deviceType === deviceType_1.DeviceType.ZigbeeAquaraMotion) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
                 d.detectionsToday = 0;
             }
         }
     }
-    processZigbeeDevice(cDevConf) {
+    static getBatteryInfo() {
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Getting Battery Info`);
+        let data = [];
+        const result = [
+            `These are the battery values for each device. Device dependandt some are in volts, some in %`,
+        ];
+        for (const key in this.alLDevices) {
+            const d = this.alLDevices[key];
+            if (d.battery !== undefined) {
+                data.push({ name: d.info.customName, amount: d.battery });
+            }
+        }
+        data = data.sort((a, b) => {
+            return a.amount - b.amount;
+        });
+        for (let i = 0; i < data.length; i++) {
+            result.push(`${data[i].amount}\t${data[i].name}`);
+        }
+        return result.join('\n');
+    }
+    static processZigbeeDevice(cDevConf) {
         const zigbeeInfo = new DeviceInfo_1.DeviceInfo(cDevConf);
         const fullName = `${Devices.IDENTIFIER_ZIGBEE}-${zigbeeInfo.devID}`;
         zigbeeInfo.allDevicesKey = fullName;
         if (typeof Devices.alLDevices[fullName] !== 'undefined') {
             return;
         }
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `${zigbeeInfo.devID} with Type "${zigbeeInfo.deviceType}" doesn't exists --> create it`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `${zigbeeInfo.devID} with Type "${zigbeeInfo.deviceType}" doesn't exists --> create it`);
         let d;
         switch (zigbeeInfo.deviceType) {
             case 'AqaraMagnetContact':
-                d = new zigbeeAqaraMagnetContact_1.ZigbeeAqaraMagnetContact(zigbeeInfo);
+                d = new zigbee_1.ZigbeeAqaraMagnetContact(zigbeeInfo);
                 break;
             case 'AqaraOpple3Switch':
-                d = new zigbeeAqaraOpple3Switch_1.ZigbeeAqaraOpple3Switch(zigbeeInfo);
+                d = new zigbee_1.ZigbeeAqaraOpple3Switch(zigbeeInfo);
                 break;
             case 'AquaraMotion':
-                d = new zigbeeAquaraMotion_1.ZigbeeAquaraMotion(zigbeeInfo);
+                d = new zigbee_1.ZigbeeAquaraMotion(zigbeeInfo);
                 break;
             case 'AquaraVibra':
-                d = new zigbeeAquaraVibra_1.ZigbeeAquaraVibra(zigbeeInfo);
+                d = new zigbee_1.ZigbeeAquaraVibra(zigbeeInfo);
                 break;
             case 'AquaraWater':
-                d = new zigbeeAquaraWater_1.ZigbeeAquaraWater(zigbeeInfo);
+                d = new zigbee_1.ZigbeeAquaraWater(zigbeeInfo);
                 break;
             case 'BlitzShp':
-                d = new zigbeeBlitzShp_1.ZigbeeBlitzShp(zigbeeInfo);
+                d = new zigbee_1.ZigbeeBlitzShp(zigbeeInfo);
                 break;
             case 'HeimanSmoke':
-                d = new zigbeeHeimanSmoke_1.ZigbeeHeimanSmoke(zigbeeInfo);
+                d = new zigbee_1.ZigbeeHeimanSmoke(zigbeeInfo);
                 break;
             case 'IkeaStecker':
-                d = new zigbeeIkeaSteckdose_1.ZigbeeIkeaSteckdose(zigbeeInfo);
+                d = new zigbee_1.ZigbeeIkeaSteckdose(zigbeeInfo);
                 break;
             case 'IlluActuator':
-                d = new zigbeeIlluActuator_1.ZigbeeIlluActuator(zigbeeInfo);
+                d = new zigbee_1.ZigbeeIlluActuator(zigbeeInfo);
                 break;
             case 'IlluDimmer':
-                d = new zigbeeIlluDimmer_1.ZigbeeIlluDimmer(zigbeeInfo);
+                d = new zigbee_1.ZigbeeIlluDimmer(zigbeeInfo);
                 break;
             case 'IlluLampe':
-                d = new zigbeeIlluLampe_1.ZigbeeIlluLampe(zigbeeInfo);
+                d = new zigbee_1.ZigbeeIlluLampe(zigbeeInfo);
                 break;
             case 'IlluShutter':
-                d = new zigbeeIlluShutter_1.ZigbeeIlluShutter(zigbeeInfo);
+                d = new zigbee_1.ZigbeeIlluShutter(zigbeeInfo);
                 break;
             case 'LedRGBCCT':
-                d = new zigbeeIlluLedRGBCCT_1.ZigbeeIlluLedRGBCCT(zigbeeInfo);
+                d = new zigbee_1.ZigbeeIlluLedRGBCCT(zigbeeInfo);
                 break;
             case 'SMaBiTMagnet':
-                d = new zigbeeSMaBiTMagnetContact_1.ZigbeeSMaBiTMagnetContact(zigbeeInfo);
+                d = new zigbee_1.ZigbeeSMaBiTMagnetContact(zigbeeInfo);
                 break;
             case 'SonoffMotion':
-                d = new zigbeeSonoffMotion_1.ZigbeeSonoffMotion(zigbeeInfo);
+                d = new zigbee_1.ZigbeeSonoffMotion(zigbeeInfo);
                 break;
             case 'SonoffTemp':
-                d = new zigbeeSonoffTemp_1.ZigbeeSonoffTemp(zigbeeInfo);
+                d = new zigbee_1.ZigbeeSonoffTemp(zigbeeInfo);
+                break;
+            case 'UbisysShutter':
+                d = new zigbeeUbisysShutter_1.ZigbeeUbisysShutter(zigbeeInfo);
                 break;
             default:
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `No zigbee Device Type for ${zigbeeInfo.deviceType} defined`);
-                d = new zigbeeDevice_1.ZigbeeDevice(zigbeeInfo, deviceType_1.DeviceType.unknown);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `No zigbee Device Type for ${zigbeeInfo.deviceType} defined`);
+                d = new zigbee_1.ZigbeeDevice(zigbeeInfo, deviceType_1.DeviceType.unknown);
         }
         Devices.alLDevices[fullName] = d;
     }
-    processHMIPDevice(cDevConf) {
+    static processHMIPDevice(cDevConf) {
         const hmIPInfo = new DeviceInfo_1.DeviceInfo(cDevConf);
         const fullName = `${Devices.IDENTIFIER_HOMEMATIC}-${hmIPInfo.devID}`;
         hmIPInfo.allDevicesKey = fullName;
         if (typeof Devices.alLDevices[fullName] !== 'undefined') {
             return;
         }
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `${hmIPInfo.devID} with Type "${hmIPInfo.deviceType}" doesn't exists --> create it`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `${hmIPInfo.devID} with Type "${hmIPInfo.deviceType}" doesn't exists --> create it`);
         let d;
         switch (hmIPInfo.deviceType) {
             case 'Lampe':
-                d = new hmIpLampe_1.HmIpLampe(hmIPInfo);
+                d = new hmIPDevices_1.HmIpLampe(hmIPInfo);
                 break;
             case 'Roll':
             case 'Broll':
-                d = new hmIpRoll_1.HmIpRoll(hmIPInfo);
+                d = new hmIPDevices_1.HmIpRoll(hmIPInfo);
                 break;
             case 'Beweg':
-                d = new hmIpBewegung_1.HmIpBewegung(hmIPInfo);
+                d = new hmIPDevices_1.HmIpBewegung(hmIPInfo);
                 break;
             case 'Taster':
-                d = new hmIpTaster_1.HmIpTaster(hmIPInfo);
+                d = new hmIPDevices_1.HmIpTaster(hmIPInfo);
                 break;
             case 'Wippe':
-                d = new hmIpWippe_1.HmIpWippe(hmIPInfo);
+                d = new hmIPDevices_1.HmIpWippe(hmIPInfo);
                 break;
             case 'Praezenz':
-                d = new hmIpPraezenz_1.HmIpPraezenz(hmIPInfo);
+                d = new hmIPDevices_1.HmIpPraezenz(hmIPInfo);
                 break;
             case 'Griff':
-                d = new hmIpGriff_1.HmIpGriff(hmIPInfo);
+                d = new hmIPDevices_1.HmIpGriff(hmIPInfo);
                 break;
             case 'Thermostat':
-                d = new hmIpTherm_1.HmIpTherm(hmIPInfo);
+                d = new hmIPDevices_1.HmIpTherm(hmIPInfo);
                 break;
             case 'Heizung':
-                d = new hmIpHeizung_1.HmIpHeizung(hmIPInfo);
+                d = new hmIPDevices_1.HmIpHeizung(hmIPInfo);
                 break;
             case 'Tuer':
-                d = new hmIpTuer_1.HmIpTuer(hmIPInfo);
+                d = new hmIPDevices_1.HmIpTuer(hmIPInfo);
                 break;
             case 'HeizGr':
-                d = new hmIpHeizgruppe_1.HmIpHeizgruppe(hmIPInfo);
+                d = new hmIPDevices_1.HmIpHeizgruppe(hmIPInfo);
                 break;
             case 'AccessPoint':
-                d = new hmIpAccessPoint_1.HmIpAccessPoint(hmIPInfo);
+                d = new hmIPDevices_1.HmIpAccessPoint(hmIPInfo);
                 break;
             default:
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `No HmIP Device Type for ${hmIPInfo.deviceType} defined`);
-                d = new hmIpDevice_1.HmIPDevice(hmIPInfo, deviceType_1.DeviceType.unknown);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `No HmIP Device Type for ${hmIPInfo.deviceType} defined`);
+                d = new hmIPDevices_1.HmIPDevice(hmIPInfo, deviceType_1.DeviceType.unknown);
         }
         Devices.alLDevices[fullName] = d;
     }
-    static getBatteryInfo() {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Getting Battery Info`);
-        let data = [];
-        const result = [
-            `These are the battery values for each device. Device dependandt some are in volts, some in %`,
-        ];
-        for (const key in this.alLDevices) {
-            const d = this.alLDevices[key];
-            if (d.battery !== undefined) {
-                data.push({ name: d.info.customName, amount: d.battery });
-            }
-        }
-        data = data.sort((a, b) => {
-            return a.amount - b.amount;
-        });
-        for (let i = 0; i < data.length; i++) {
-            result.push(`${data[i].amount}\t${data[i].name}`);
-        }
-        return result.join('\n');
-    }
-    createEnergyManager(cDevConf) {
+    static createEnergyManager(cDevConf) {
         const devInfo = new DeviceInfo_1.DeviceInfo(cDevConf, true);
         const fullName = `${Devices.IDENTIFIER_JS}-${devInfo.devID}`;
         devInfo.allDevicesKey = fullName;
-        Devices.energymanager = new jsObjectEnergyManager_1.JsObjectEnergyManager(devInfo);
+        Devices.energymanager = new jsObject_1.JsObjectEnergyManager(devInfo);
         Devices.alLDevices[fullName] = Devices.energymanager;
     }
 }

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

@@ -1,6 +1,5 @@
-import { ZigbeeIkeaSteckdose } from '../zigbee/zigbeeIkeaSteckdose';
-import { TimeOfDay } from '../../services/time-callback-service';
-import { ZigbeeIlluLedRGBCCT } from '../zigbee/zigbeeIlluLedRGBCCT';
+import { ZigbeeIkeaSteckdose, ZigbeeIlluLedRGBCCT } from '../zigbee';
+import { TimeOfDay } from '../../services';
 import { BaseGroup } from './base-group';
 import { iLamp } from '../iLamp';
 export declare class LampenGroup extends BaseGroup {
@@ -11,7 +10,7 @@ export declare class LampenGroup extends BaseGroup {
     getStecker(): ZigbeeIkeaSteckdose[];
     switchAll(target: boolean, force?: boolean): void;
     switchTimeConditional(time: TimeOfDay): void;
-    setAllLampen(pValue: boolean, time?: TimeOfDay, force?: boolean): void;
+    setAllLampen(pValue: boolean, time?: TimeOfDay, force?: boolean, timeout?: number): void;
     setAllStecker(pValue: boolean, time?: TimeOfDay, force?: boolean): void;
     setAllLED(pValue: boolean, brightness?: number, color?: string, colortemp?: number): void;
 }

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,36 +50,36 @@ 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);
         this.setAllStecker(resultSteckdosen, time);
     }
-    setAllLampen(pValue, time, force = false) {
+    setAllLampen(pValue, time, force = false, timeout) {
         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)) {
-                const timeout = pValue && force ? 30 * 60 * 1000 : -1;
+                (time === services_1.TimeOfDay.Night && s.settings.nightOn) ||
+                (time === services_1.TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
+                (time === services_1.TimeOfDay.AfterSunset && s.settings.duskOn)) {
+                timeout !== null && timeout !== void 0 ? timeout : (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;
 }