hoffmation-base 0.1.14 → 0.1.18

package/lib/server/devices/devices.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Devices = void 0;
+const logLevel_1 = require("../../models/logLevel");
+const hmIpDeviceType_1 = require("./hmIPDevices/hmIpDeviceType");
+const zigbeeDeviceType_1 = require("./zigbee/zigbeeDeviceType");
+const log_service_1 = require("../services/log-service");
+const hmIpDevice_1 = require("./hmIPDevices/hmIpDevice");
+const zigbeeDevice_1 = require("./zigbee/zigbeeDevice");
+const hmIpGriff_1 = require("./hmIPDevices/hmIpGriff");
+const hmIpHeizung_1 = require("./hmIPDevices/hmIpHeizung");
+const DeviceInfo_1 = require("./DeviceInfo");
+const hmIpLampe_1 = require("./hmIPDevices/hmIpLampe");
+const hmIpPraezenz_1 = require("./hmIPDevices/hmIpPraezenz");
+const hmIpRoll_1 = require("./hmIPDevices/hmIpRoll");
+const hmIpTaster_1 = require("./hmIPDevices/hmIpTaster");
+const hmIpTherm_1 = require("./hmIPDevices/hmIpTherm");
+const hmIpTuer_1 = require("./hmIPDevices/hmIpTuer");
+const hmIpWippe_1 = require("./hmIPDevices/hmIpWippe");
+const hmIpHeizgruppe_1 = require("./hmIPDevices/hmIpHeizgruppe");
+const hmIpBewegung_1 = require("./hmIPDevices/hmIpBewegung");
+const zigbeeIkeaSteckdose_1 = require("./zigbee/zigbeeIkeaSteckdose");
+const zigbeeIlluLedRGBCCT_1 = require("./zigbee/zigbeeIlluLedRGBCCT");
+const zigbeeAquaraVibra_1 = require("./zigbee/zigbeeAquaraVibra");
+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 zigbeeAquaraMotion_1 = require("./zigbee/zigbeeAquaraMotion");
+class Devices {
+    constructor(pDeviceData, pRoomImportEnforcer) {
+        // This forces import of rooms at correct timing, to allow devices to land in proper rooms.
+        pRoomImportEnforcer.addRoomConstructor();
+        for (const cID in pDeviceData) {
+            const cDevConf = pDeviceData[cID];
+            if (!cDevConf.common ||
+                !cDevConf.common.name ||
+                typeof cDevConf.common.name === 'object' ||
+                !cDevConf.type ||
+                cDevConf.type === 'channel') {
+                continue;
+            }
+            const cName = cDevConf.common.name;
+            if (cName.indexOf('00-HmIP') === 0) {
+                this.processHMIPDevice(cDevConf);
+            }
+            else if (cName.indexOf('00-Zigbee') === 0) {
+                this.processZigbeeDevice(cDevConf);
+            }
+        }
+        hmIpDevice_1.HmIPDevice.checkMissing();
+        zigbeeDevice_1.ZigbeeDevice.checkMissing();
+    }
+    static addIoConnection(pIoConnection) {
+        for (const id in Devices.hmIP) {
+            Devices.hmIP[id].ioConn = pIoConnection;
+        }
+        for (const id in Devices.Zigbee) {
+            Devices.Zigbee[id].ioConn = pIoConnection;
+        }
+    }
+    static midnightReset() {
+        // Nothing yet
+    }
+    static resetPraesenzCount() {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `3 Uhr Reset der Präsenzmelder`);
+        for (const dID in Devices.hmIP) {
+            const d = Devices.hmIP[dID];
+            if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpPraezenz) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                d.detectionsToday = 0;
+            }
+            else if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpBewegung) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
+                d.detectionsToday = 0;
+            }
+        }
+    }
+    processZigbeeDevice(cDevConf) {
+        const zigbeeInfo = new DeviceInfo_1.DeviceInfo(cDevConf);
+        if (typeof Devices.Zigbee[zigbeeInfo.devID] !== 'undefined') {
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `${zigbeeInfo.devID} with Type "${zigbeeInfo.deviceType}" doesn't exists --> create it`);
+        switch (zigbeeInfo.deviceType) {
+            case 'AquaraVibra':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeAquaraVibra_1.ZigbeeAquaraVibra(zigbeeInfo);
+                break;
+            case 'AquaraMotion':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeAquaraMotion_1.ZigbeeAquaraMotion(zigbeeInfo);
+                break;
+            case 'IkeaStecker':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeIkeaSteckdose_1.ZigbeeIkeaSteckdose(zigbeeInfo);
+                break;
+            case 'LedRGBCCT':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeIlluLedRGBCCT_1.ZigbeeIlluLedRGBCCT(zigbeeInfo);
+                break;
+            case 'IlluDimmer':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeIlluDimmer_1.ZigbeeIlluDimmer(zigbeeInfo);
+                break;
+            case 'HeimanSmoke':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeHeimanSmoke_1.ZigbeeHeimanSmoke(zigbeeInfo);
+                break;
+            case 'AquaraWater':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeAquaraWater_1.ZigbeeAquaraWater(zigbeeInfo);
+                break;
+            case 'BlitzShp':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeBlitzShp_1.ZigbeeBlitzShp(zigbeeInfo);
+                break;
+            case 'IlluLampe':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeIlluLampe_1.ZigbeeIlluLampe(zigbeeInfo);
+                break;
+            case 'IlluActuator':
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeIlluActuator_1.ZigbeeIlluActuator(zigbeeInfo);
+                break;
+            default:
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `No zigbee Device Type for ${zigbeeInfo.deviceType} defined`);
+                Devices.Zigbee[zigbeeInfo.devID] = new zigbeeDevice_1.ZigbeeDevice(zigbeeInfo, zigbeeDeviceType_1.ZigbeeDeviceType.unknown);
+        }
+    }
+    processHMIPDevice(cDevConf) {
+        const hmIPInfo = new DeviceInfo_1.DeviceInfo(cDevConf);
+        if (typeof Devices.hmIP[hmIPInfo.devID] !== 'undefined') {
+            return;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `${hmIPInfo.devID} with Type "${hmIPInfo.deviceType}" doesn't exists --> create it`);
+        switch (hmIPInfo.deviceType) {
+            case 'Lampe':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpLampe_1.HmIpLampe(hmIPInfo);
+                break;
+            case 'Roll':
+            case 'Broll':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpRoll_1.HmIpRoll(hmIPInfo);
+                break;
+            case 'Beweg':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpBewegung_1.HmIpBewegung(hmIPInfo);
+                break;
+            case 'Taster':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpTaster_1.HmIpTaster(hmIPInfo);
+                break;
+            case 'Wippe':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpWippe_1.HmIpWippe(hmIPInfo);
+                break;
+            case 'Praezenz':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpPraezenz_1.HmIpPraezenz(hmIPInfo);
+                break;
+            case 'Griff':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpGriff_1.HmIpGriff(hmIPInfo);
+                break;
+            case 'Thermostat':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpTherm_1.HmIpTherm(hmIPInfo);
+                break;
+            case 'Heizung':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpHeizung_1.HmIpHeizung(hmIPInfo);
+                break;
+            case 'Tuer':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpTuer_1.HmIpTuer(hmIPInfo);
+                break;
+            case 'HeizGr':
+                Devices.hmIP[hmIPInfo.devID] = new hmIpHeizgruppe_1.HmIpHeizgruppe(hmIPInfo);
+                break;
+            default:
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `No HmIP Device Type for ${hmIPInfo.deviceType} defined`);
+                Devices.hmIP[hmIPInfo.devID] = new hmIpDevice_1.HmIPDevice(hmIPInfo, hmIpDeviceType_1.HmIpDeviceType.unknown);
+        }
+    }
+}
+exports.Devices = Devices;
+Devices.hmIP = {};
+Devices.Zigbee = {};

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

@@ -0,0 +1,15 @@
+import { Fenster } from '../hmIPDevices/Fenster';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+export declare class FensterGroup {
+    private _room;
+    fenster: Fenster[];
+    constructor(_room: RoomBase, fenster: Fenster[]);
+    allRolloDown(initial?: boolean, savePosition?: boolean): void;
+    allRolloUp(savePosition?: boolean): void;
+    allRolloToLevel(level: number, savePosition?: boolean): void;
+    initCallbacks(): void;
+    private sunsetDown;
+    setRolloByWeatherStatus(): void;
+    sunriseUp(initial?: boolean): void;
+    restoreRolloPosition(recalc?: boolean): void;
+}

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FensterGroup = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const FensterPosition_1 = require("../hmIPDevices/FensterPosition");
+const log_service_1 = require("../../services/log-service");
+const timeCallback_1 = require("../../../models/timeCallback");
+const time_callback_service_1 = require("../../services/time-callback-service");
+const utils_1 = require("../../services/utils/utils");
+const weather_service_1 = require("../../services/weather/weather-service");
+class FensterGroup {
+    constructor(_room, fenster) {
+        this._room = _room;
+        this.fenster = fenster;
+        for (const f of [...fenster]) {
+            f.room = this._room;
+        }
+    }
+    allRolloDown(initial = false, savePosition = false) {
+        this.fenster.forEach((f) => {
+            if (savePosition)
+                f.desiredPosition = 0;
+            if (f.rollo !== undefined) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fahre das Rollo zum Sonnenuntergang ${initial ? '(ggf. nachträglich) ' : ''}für ${f.rollo.info.customName} runter`);
+                f.rollo.down(initial);
+            }
+        });
+    }
+    allRolloUp(savePosition = false) {
+        this.fenster.forEach((f) => {
+            if (f.rollo === undefined) {
+                return;
+            }
+            if (savePosition) {
+                f.desiredPosition = 100;
+            }
+            f.rollo.up(false);
+        });
+    }
+    allRolloToLevel(level, savePosition = false) {
+        this.fenster.forEach((f) => {
+            if (savePosition) {
+                f.desiredPosition = level;
+            }
+            if (f.rollo !== undefined) {
+                f.rollo.setLevel(level, false);
+            }
+        });
+    }
+    initCallbacks() {
+        if (this._room.Einstellungen.sonnenAufgangRollos && this._room.Einstellungen.rolloOffset) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Sonnenaufgang TimeCallback für ${this._room.roomName} hinzufügen`);
+            this._room.sonnenAufgangCallback = new timeCallback_1.TimeCallback(`${this._room.roomName} Sonnenaufgang Rollos`, timeCallback_1.TimeCallbackType.Sunrise, () => {
+                if (this._room.skipNextRolloUp) {
+                    this._room.skipNextRolloUp = false;
+                    return;
+                }
+                this.sunriseUp();
+            }, this._room.Einstellungen.rolloOffset.sunrise, undefined, undefined, this._room.Einstellungen.rolloOffset);
+            if (!time_callback_service_1.TimeCallbackService.darkOutsideOrNight(time_callback_service_1.TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset))) {
+                this.sunriseUp(true);
+            }
+            time_callback_service_1.TimeCallbackService.addCallback(this._room.sonnenAufgangCallback);
+        }
+        if (this._room.Einstellungen.sonnenUntergangRollos && this._room.Einstellungen.rolloOffset) {
+            this._room.sonnenUntergangCallback = new timeCallback_1.TimeCallback(`${this._room.roomName} Sonnenuntergang Rollo`, timeCallback_1.TimeCallbackType.SunSet, () => {
+                this.sunsetDown();
+            }, this._room.Einstellungen.rolloOffset.sunset);
+            if (time_callback_service_1.TimeCallbackService.darkOutsideOrNight(time_callback_service_1.TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset))) {
+                utils_1.Utils.guardedTimeout(() => {
+                    this.allRolloDown(true, true);
+                }, 60000, this);
+            }
+            time_callback_service_1.TimeCallbackService.addCallback(this._room.sonnenUntergangCallback);
+        }
+        if (this._room.Einstellungen.rolloHeatReduction) {
+            utils_1.Utils.guardedInterval(this.setRolloByWeatherStatus, 15 * 60 * 1000, this, true);
+            utils_1.Utils.guardedTimeout(this.setRolloByWeatherStatus, 2 * 60 * 1000, this);
+        }
+    }
+    sunsetDown() {
+        this.allRolloToLevel(0, true);
+        if (this._room.PraesenzGroup.anyPresent() && this._room.Einstellungen.lampOffset) {
+            this._room.LampenGroup.switchTimeConditional(time_callback_service_1.TimeCallbackService.dayType(this._room.Einstellungen.lampOffset));
+        }
+    }
+    setRolloByWeatherStatus() {
+        const timeOfDay = time_callback_service_1.TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset);
+        const darkOutside = time_callback_service_1.TimeCallbackService.darkOutsideOrNight(timeOfDay);
+        this.fenster.forEach((f) => {
+            if (!f.rollo) {
+                return;
+            }
+            if (darkOutside) {
+                f.restoreDesiredPosition();
+                return;
+            }
+            let desiredPos = f.desiredPosition;
+            if (desiredPos > 0) {
+                weather_service_1.WeatherService.weatherRolloPosition(desiredPos, this._room.HeatGroup.desiredTemp, this._room.HeatGroup.currentTemp);
+            }
+            if (f.griffeInPosition(FensterPosition_1.FensterPosition.offen) > 0 && desiredPos < 100) {
+                return;
+            }
+            if (f.griffeInPosition(FensterPosition_1.FensterPosition.kipp) > 0) {
+                desiredPos = Math.max(30, desiredPos);
+            }
+            if (f.rollo.currentLevel === desiredPos) {
+                // Rollo ist bereits auf der Zielposition
+                return;
+            }
+            f.rollo.setLevel(desiredPos, false, true);
+        });
+    }
+    sunriseUp(initial = false) {
+        this.fenster.forEach((f) => {
+            if (!f.noRolloOnSunrise && f.rollo) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fahre das Rollo zum Sonnenaufgang ${initial ? '(ggf. nachträglich)' : ''}für ${f.rollo.info.customName} hoch`);
+                f.setDesiredPosition(100);
+            }
+        });
+    }
+    restoreRolloPosition(recalc = false) {
+        if (!recalc) {
+            this.fenster.forEach((f) => {
+                f.restoreDesiredPosition();
+            });
+            return;
+        }
+        if (!time_callback_service_1.TimeCallbackService.darkOutsideOrNight(time_callback_service_1.TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset))) {
+            this.sunriseUp(true);
+        }
+        else {
+            this.sunsetDown();
+        }
+    }
+}
+exports.FensterGroup = FensterGroup;

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

@@ -0,0 +1,9 @@
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { HmIpHeizgruppe } from '../hmIPDevices/hmIpHeizgruppe';
+export declare class HeatGroup {
+    private _room;
+    heaters: HmIpHeizgruppe[];
+    get currentTemp(): number;
+    get desiredTemp(): number;
+    constructor(_room: RoomBase, heaters: HmIpHeizgruppe[]);
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeatGroup = void 0;
+class HeatGroup {
+    constructor(_room, heaters) {
+        this._room = _room;
+        this.heaters = heaters;
+        for (const h of [...heaters]) {
+            h.room = this._room;
+        }
+    }
+    get currentTemp() {
+        if (this.heaters.length === 0) {
+            return -99;
+        }
+        let value = 0;
+        for (const h of this.heaters) {
+            value += h.iTemperatur;
+        }
+        return Math.round((value / this.heaters.length) * 10) / 10;
+    }
+    get desiredTemp() {
+        if (this.heaters.length === 0) {
+            return -99;
+        }
+        let value = 0;
+        for (const h of this.heaters) {
+            value += h.desiredTemperatur;
+        }
+        return Math.round((value / this.heaters.length) * 10) / 10;
+    }
+}
+exports.HeatGroup = HeatGroup;

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

@@ -0,0 +1,8 @@
+export * from './heatGroup';
+export * from './smokeGroup';
+export * from './sonosGroup';
+export * from './waterGroup';
+export * from './lampenGroup';
+export * from './tasterGroup';
+export * from './fensterGroup';
+export * from './praesenzGroup';

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./heatGroup"), exports);
+__exportStar(require("./smokeGroup"), exports);
+__exportStar(require("./sonosGroup"), exports);
+__exportStar(require("./waterGroup"), exports);
+__exportStar(require("./lampenGroup"), exports);
+__exportStar(require("./tasterGroup"), exports);
+__exportStar(require("./fensterGroup"), exports);
+__exportStar(require("./praesenzGroup"), exports);

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

@@ -0,0 +1,18 @@
+import { ZigbeeIkeaSteckdose } from '../zigbee/zigbeeIkeaSteckdose';
+import { ZigbeeIlluLedRGBCCT } from '../zigbee/zigbeeIlluLedRGBCCT';
+import { TimeOfDay } from '../../services/time-callback-service';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { iLamp } from '../iLamp';
+export declare class LampenGroup {
+    private _room;
+    Lampen: Array<iLamp>;
+    Stecker: Array<ZigbeeIkeaSteckdose>;
+    LED: Array<ZigbeeIlluLedRGBCCT>;
+    constructor(_room: RoomBase, Lampen: Array<iLamp>, Stecker: Array<ZigbeeIkeaSteckdose>, LED?: Array<ZigbeeIlluLedRGBCCT>);
+    anyLightsOwn(): boolean;
+    switchAll(target: boolean, force?: boolean): void;
+    switchTimeConditional(time: TimeOfDay): void;
+    setAllLampen(pValue: boolean, time?: TimeOfDay, force?: boolean): 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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LampenGroup = void 0;
+const time_callback_service_1 = require("../../services/time-callback-service");
+class LampenGroup {
+    constructor(_room, Lampen, Stecker, LED = []) {
+        this._room = _room;
+        this.Lampen = Lampen;
+        this.Stecker = Stecker;
+        this.LED = LED;
+        for (const lamp of [...Lampen, ...Stecker, ...LED]) {
+            lamp.room = this._room;
+        }
+    }
+    anyLightsOwn() {
+        let i;
+        for (i = 0; i < this.Lampen.length; i++) {
+            if (this.Lampen[i].lightOn) {
+                return true;
+            }
+        }
+        for (i = 0; i < this.LED.length; i++) {
+            if (this.LED[i].on) {
+                return true;
+            }
+        }
+        for (i = 0; i < this.Stecker.length; i++) {
+            if (this.Stecker[i].steckerOn) {
+                return true;
+            }
+        }
+        return false;
+    }
+    switchAll(target, force = false) {
+        this.setAllLampen(target, undefined, force);
+        this.setAllStecker(target, undefined, force);
+        this.LED.forEach((s) => {
+            s.setLight(target);
+        });
+    }
+    switchTimeConditional(time) {
+        const darkOutside = time_callback_service_1.TimeCallbackService.darkOutsideOrNight(time);
+        let resultLampen = false;
+        let resultSteckdosen = false;
+        if (this.LED.length > 0) {
+            this.LED.forEach((s) => {
+                s.setTimeBased(time);
+            });
+        }
+        else if (this.Stecker.length > 0) {
+            resultSteckdosen = darkOutside;
+        }
+        else {
+            resultLampen = darkOutside;
+        }
+        this.setAllLampen(resultLampen, time);
+        this.setAllStecker(resultSteckdosen, time);
+    }
+    setAllLampen(pValue, time, force = false) {
+        var _a;
+        if (((_a = this.Lampen) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            this.Lampen.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;
+                    s.setLight(pValue, timeout, force);
+                }
+            });
+        }
+    }
+    setAllStecker(pValue, time, force = false) {
+        var _a;
+        if (((_a = this.Stecker) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            this.Stecker.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;
+                    s.setStecker(pValue, timeout, force);
+                }
+            });
+        }
+    }
+    setAllLED(pValue, brightness = -1, color = '', colortemp = -1) {
+        this.LED.forEach((s) => {
+            s.setLight(pValue, brightness, color, colortemp);
+        });
+    }
+}
+exports.LampenGroup = LampenGroup;

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

@@ -0,0 +1,18 @@
+import { HmIpPraezenz } from '../hmIPDevices/hmIpPraezenz';
+import { HmIpBewegung } from '../hmIPDevices/hmIpBewegung';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { ZigbeeAquaraMotion } from '../zigbee/zigbeeAquaraMotion';
+export declare class PraesenzGroup {
+    private _room;
+    Prasenzen: HmIpPraezenz[];
+    Bewegungen: HmIpBewegung[] | ZigbeeAquaraMotion[];
+    private _lastMovement;
+    constructor(_room: RoomBase, Prasenzen: HmIpPraezenz[], Bewegungen: HmIpBewegung[] | ZigbeeAquaraMotion[]);
+    initCallbacks(): void;
+    presentAmount(): number;
+    anyPresent(): boolean;
+    lastLeftCB(val: boolean, cb: () => void): void;
+    addLastLeftCallback(cb: () => void): void;
+    private firstEnterCallback;
+    addFirstEnterCallback(cb: () => void): void;
+}