hoffmation-base 0.1.14 → 0.1.18

package/lib/models/rooms/RoomBase.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomBase = void 0;
+const hmIpDevice_1 = require("../../server/devices/hmIPDevices/hmIpDevice");
+const tasterGroup_1 = require("../../server/devices/groups/tasterGroup");
+const praesenzGroup_1 = require("../../server/devices/groups/praesenzGroup");
+const ringstorage_1 = require("../../server/services/utils/ringstorage");
+const telegram_service_1 = require("../../server/services/Telegram/telegram-service");
+const heatGroup_1 = require("../../server/devices/groups/heatGroup");
+const logLevel_1 = require("../logLevel");
+const waterGroup_1 = require("../../server/devices/groups/waterGroup");
+const log_service_1 = require("../../server/services/log-service");
+const utils_1 = require("../../server/services/utils/utils");
+const lampenGroup_1 = require("../../server/devices/groups/lampenGroup");
+const smokeGroup_1 = require("../../server/devices/groups/smokeGroup");
+const fensterGroup_1 = require("../../server/devices/groups/fensterGroup");
+const zigbeeDevice_1 = require("../../server/devices/zigbee/zigbeeDevice");
+const persist_1 = require("../../server/services/dbo/persist");
+const time_callback_service_1 = require("../../server/services/time-callback-service");
+const sonos_service_1 = require("../../server/services/Sonos/sonos-service");
+const sonosGroup_1 = require("../../server/devices/groups/sonosGroup");
+class RoomBase {
+    constructor(roomName, Einstellungen) {
+        this.roomName = roomName;
+        this.Einstellungen = Einstellungen;
+        this.FensterGroup = new fensterGroup_1.FensterGroup(this, []);
+        this.PraesenzGroup = new praesenzGroup_1.PraesenzGroup(this, [], []);
+        this.LampenGroup = new lampenGroup_1.LampenGroup(this, [], [], []);
+        this.TasterGroup = new tasterGroup_1.TasterGroup(this, []);
+        this.SonosGroup = new sonosGroup_1.SonosGroup(this, []);
+        this.SmokeGroup = new smokeGroup_1.SmokeGroup(this, []);
+        this.WaterGroup = new waterGroup_1.WaterGroup(this, []);
+        this.HeatGroup = new heatGroup_1.HeatGroup(this, []);
+        this.skipNextRolloUp = false;
+        if (Einstellungen.etage !== undefined) {
+            const level = Einstellungen.etage;
+            if (RoomBase.floors[level] === undefined) {
+                RoomBase.floors[level] = [];
+            }
+            RoomBase.floors[level].push(this);
+        }
+        Einstellungen.room = this;
+        this.Settings = Einstellungen;
+        RoomBase.allRooms.push(this);
+    }
+    static registerRoomForDevices(roomSettings) {
+        if (roomSettings.hmIpSettings !== undefined) {
+            hmIpDevice_1.HmIPDevice.addRoom(roomSettings.shortName, roomSettings.hmIpSettings);
+        }
+        if (roomSettings.zigbeeSettings !== undefined) {
+            zigbeeDevice_1.ZigbeeDevice.addRoom(roomSettings.shortName, roomSettings.zigbeeSettings);
+        }
+    }
+    static addToRoomList(room) {
+        RoomBase.Rooms[room.roomName] = room;
+    }
+    static getAllRoomsOfFloor(floor) {
+        return this.floors[floor];
+    }
+    /**
+     * Set ALl Roolos of a specific floor
+     * !!floor -1 sets all rollos in house instead!!
+     * @param floor the level on which all rollos shall be changed -1 equals all rooms
+     * @param position (0 equals down, 100 up)
+     */
+    static setAllRolloOfFloor(floor = -1, position = 0) {
+        const rooms = floor > -1 ? this.getAllRoomsOfFloor(floor) : this.allRooms;
+        for (const room of rooms) {
+            room.FensterGroup.allRolloToLevel(position, true);
+        }
+    }
+    /**
+     * Set ALl Lamps of a specific floor
+     * !!floor -1 sets all lamps in house instead!!
+     * @param floor the level on which all lamps shall be changed -1 equals all rooms
+     * @param status
+     */
+    static setAllLampsOfFloor(floor, status = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Schalte alle Lampen in Etage ${floor} auf den Wert ${status}`);
+        const rooms = floor > -1 ? this.getAllRoomsOfFloor(floor) : this.allRooms;
+        for (const room of rooms) {
+            room.LampenGroup.setAllLampen(status, -1, true);
+            room.LampenGroup.setAllLED(status);
+            room.LampenGroup.setAllStecker(status, -1, true);
+        }
+    }
+    static clearAllAlarms() {
+        for (const r of RoomBase.allRooms) {
+            if (r.WaterGroup) {
+                r.WaterGroup.stopAlarm();
+            }
+            if (r.SmokeGroup) {
+                r.SmokeGroup.stopAlarm();
+            }
+        }
+        this.stopIntrusionAlarm();
+        this.restoreRolloPosition();
+        this.restoreLight();
+    }
+    static startAwayMode() {
+        sonos_service_1.SonosService.speakOnAll(`Alarmanlage wird scharfgeschaltet.`, 40);
+        if (this._awayModeTimer) {
+            clearTimeout(this._awayModeTimer);
+        }
+        this._awayModeTimer = utils_1.Utils.guardedTimeout(() => {
+            this.awayModeActive = true;
+            this._awayModeTimer = undefined;
+            telegram_service_1.TelegramService.inform(`Alarm ist nun scharf. Gute Reise!`);
+        }, 60000, this);
+    }
+    static startNightAlarmMode() {
+        sonos_service_1.SonosService.speakOnAll(`Alarmanlage wird für die Nacht scharfgeschaltet. Gute Nacht!`, 30);
+        if (this._nightModeTimer) {
+            clearTimeout(this._nightModeTimer);
+        }
+        this._nightModeTimer = utils_1.Utils.guardedTimeout(() => {
+            this.nightAlarmActive = true;
+            this._nightModeTimer = undefined;
+            telegram_service_1.TelegramService.inform(`Alarm ist nun scharf. Süße Träume!`);
+        }, 60000, this);
+    }
+    static startIntrusionAlarm(room, device) {
+        const message = `!Potenzieller Eindringling! Bewegung in ${room.roomName} von ${device.info.fullName} festgestellt`;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, message);
+        if (!this.awayModeActive && !this.nightAlarmActive) {
+            this.stopIntrusionAlarm();
+            return;
+        }
+        utils_1.Utils.guardedNewThread(() => {
+            telegram_service_1.TelegramService.inform(message);
+        }, this);
+        if (this._intrusionAlarmActive) {
+            return;
+        }
+        this._intrusionAlarmActive = true;
+        this.performNextIntrusionLevel();
+    }
+    static endAlarmModes() {
+        if (this.awayModeActive) {
+            telegram_service_1.TelegramService.sendMessage(telegram_service_1.TelegramService.subscribedIDs, `Alarmanalage entschärft`);
+            sonos_service_1.SonosService.speakOnAll(`Willkommen Zuhause!`, 35);
+        }
+        if (this.nightAlarmActive) {
+            telegram_service_1.TelegramService.sendMessage(telegram_service_1.TelegramService.subscribedIDs, `Nachtmodus der Alarmanlage entschärft`);
+            sonos_service_1.SonosService.speakOnAll(`Guten Morgen!`, 30);
+        }
+        if (this._nightModeTimer) {
+            clearTimeout(this._nightModeTimer);
+        }
+        if (this._awayModeTimer) {
+            clearTimeout(this._awayModeTimer);
+        }
+        this.awayModeActive = false;
+        this.nightAlarmActive = false;
+        this.stopIntrusionAlarm();
+    }
+    static getLastMovements() {
+        return this.movementHistory.readAmount(15).join('\n');
+    }
+    initializeBase() {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `RoomBase Init für ${this.roomName}`);
+        this.recalcTimeCallbacks();
+        this.PraesenzGroup.initCallbacks();
+        this.FensterGroup.initCallbacks();
+        this.TasterGroup.initCallbacks();
+    }
+    persist() {
+        persist_1.Persist.addRoom(this);
+    }
+    recalcTimeCallbacks() {
+        const now = new Date();
+        if (this.sonnenAufgangCallback && this.Einstellungen.rolloOffset) {
+            this.sonnenAufgangCallback.minuteOffset = this.Einstellungen.rolloOffset.sunrise;
+            this.sonnenAufgangCallback.sunTimeOffset = this.Einstellungen.rolloOffset;
+            this.sonnenAufgangCallback.recalcNextToDo(now);
+        }
+        if (this.sonnenUntergangCallback && this.Einstellungen.rolloOffset) {
+            this.sonnenUntergangCallback.minuteOffset = this.Einstellungen.rolloOffset.sunset;
+            this.sonnenUntergangCallback.sunTimeOffset = this.Einstellungen.rolloOffset;
+            this.sonnenUntergangCallback.recalcNextToDo(now);
+        }
+        if (this.sonnenAufgangLichtCallback && this.Einstellungen.lampOffset) {
+            this.sonnenAufgangLichtCallback.minuteOffset = this.Einstellungen.lampOffset.sunrise;
+            this.sonnenAufgangLichtCallback.recalcNextToDo(now);
+        }
+    }
+    /**
+     * Sets the light based on the current time, rollo Position and room Settings
+     * @param movementDependant Only turn light on if there was a movement in the same room
+     */
+    setLightTimeBased(movementDependant = false) {
+        if (movementDependant && !this.PraesenzGroup.anyPresent()) {
+            this.LampenGroup.switchAll(false);
+            return;
+        }
+        if (!this.Einstellungen.lampOffset) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Beim Aufruf von "setLightTimeBased" im Raum ${this.roomName} liegt kein Lampen Offset vor`);
+            return;
+        }
+        let timeOfDay = time_callback_service_1.TimeCallbackService.dayType(this.Einstellungen.lampOffset);
+        if (timeOfDay === time_callback_service_1.TimeOfDay.Daylight &&
+            ((this.Einstellungen.lightIfNoWindows && this.FensterGroup.fenster.length === 0) ||
+                this.FensterGroup.fenster.some((f) => {
+                    var _a, _b;
+                    const rolloDown = ((_a = f.rollo) === null || _a === void 0 ? void 0 : _a.currentLevel) === 0;
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Rollo ${(_b = f.rollo) === null || _b === void 0 ? void 0 : _b.info.customName} for light in ${this.roomName} is ${rolloDown ? '' : 'not '}down`);
+                    return rolloDown;
+                }))) {
+            timeOfDay = time_callback_service_1.TimeOfDay.AfterSunset;
+        }
+        this.LampenGroup.switchTimeConditional(timeOfDay);
+    }
+    isNowLightTime() {
+        if (!this.Einstellungen.lampOffset) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Beim Aufruf von "setLightTimeBased" im Raum ${this.roomName} liegt kein Lampen Offset vor`);
+            return false;
+        }
+        let timeOfDay = time_callback_service_1.TimeCallbackService.dayType(this.Einstellungen.lampOffset);
+        if (timeOfDay === time_callback_service_1.TimeOfDay.Daylight &&
+            this.FensterGroup.fenster.some((f) => {
+                var _a;
+                return ((_a = f.rollo) === null || _a === void 0 ? void 0 : _a.currentLevel) === 0;
+            })) {
+            timeOfDay = time_callback_service_1.TimeOfDay.AfterSunset;
+        }
+        return time_callback_service_1.TimeCallbackService.darkOutsideOrNight(timeOfDay);
+    }
+    static stopIntrusionAlarm() {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Stoppe Intrusion Alarm`);
+        if (this._intrusionAlarmTimeout) {
+            clearTimeout(this._intrusionAlarmTimeout);
+        }
+        if (!this._intrusionAlarmActive) {
+            return;
+        }
+        this._intrusionAlarmActive = false;
+        this._intrusionAlarmLevel = 0;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Alarm wurde beendet --> Fahre Rollos in Ausgangsposition.`);
+        this.restoreRolloPosition();
+        this.restoreLight();
+    }
+    static performNextIntrusionLevel() {
+        this._intrusionAlarmTimeout = undefined;
+        if (!this.awayModeActive && !this._intrusionAlarmActive) {
+            return;
+        }
+        this._intrusionAlarmLevel += 1;
+        let speakMessage;
+        let volume = 50;
+        let newTimeout = 20000;
+        const alarmAutomaticEnd = 15;
+        if (this._intrusionAlarmLevel === 1) {
+            speakMessage = `Hallo potenzieller Eindringling! Das Alarmprotokoll ist initiiert bitte verlassen Sie umgehend das Gebäude!`;
+            volume = 40;
+        }
+        else if (this._intrusionAlarmLevel === 2) {
+            speakMessage = `Alle Rollos fahren hoch, bitte begeben Sie sich zum nächsten Ausgang`;
+            utils_1.Utils.guardedNewThread(() => {
+                this.setAllRolloOfFloor(-1, 100);
+                this.setAllLampsOfFloor(-1, true);
+            }, this);
+        }
+        else if (this._intrusionAlarmLevel === 3) {
+            volume = 70;
+            speakMessage = `Verlassen Sie sofort das Gebäude! Die Behörden sind informiert`;
+        }
+        else if (this._intrusionAlarmLevel <= 5) {
+            volume = 80;
+            speakMessage = `Weitere Abwehrmaßnahmen werden eingeleitet`;
+        }
+        else if (this._intrusionAlarmLevel >= alarmAutomaticEnd) {
+            this.stopIntrusionAlarm();
+            return;
+        }
+        else {
+            volume = 90;
+            speakMessage = `Alarm. Einbrecher erkannt.`;
+            newTimeout = 10000;
+        }
+        this._intrusionAlarmTimeout = utils_1.Utils.guardedTimeout(() => {
+            this.performNextIntrusionLevel();
+        }, newTimeout, this);
+        utils_1.Utils.guardedNewThread(() => {
+            sonos_service_1.SonosService.speakOnAll(speakMessage, volume);
+            telegram_service_1.TelegramService.inform(`Eindringling erhielt folgende Nachricht: "${speakMessage}"\nAlarmlevel ist ${this._intrusionAlarmLevel}\t Automatisches Ende bei ${alarmAutomaticEnd}`);
+        }, this);
+    }
+    static restoreRolloPosition() {
+        const rooms = this.allRooms;
+        for (const room of rooms) {
+            room.FensterGroup.restoreRolloPosition();
+        }
+    }
+    static restoreLight() {
+        const rooms = this.allRooms;
+        for (const room of rooms) {
+            room.setLightTimeBased(true);
+        }
+    }
+}
+exports.RoomBase = RoomBase;
+RoomBase.Rooms = {};
+RoomBase.allRooms = [];
+RoomBase.floors = {};
+RoomBase.awayModeActive = false;
+RoomBase.nightAlarmActive = false;
+RoomBase.movementHistory = new ringstorage_1.ringStorage(15);
+RoomBase._intrusionAlarmActive = false;
+RoomBase._intrusionAlarmLevel = 0;

package/lib/models/rooms/RoomSettings/RoomSettings.d.ts

@@ -0,0 +1,57 @@
+import { HmIpRoomSettings } from './hmIPRoomSettings';
+import { ZigbeeRoomSettings } from './zigbeeRoomSettings';
+import { iRoomDefaultSettings } from './iRoomDefaultSettings';
+import { SunTimeOffsets } from '../../../server/services/time-callback-service';
+import { RoomBase } from '../RoomBase';
+import { iTimePair } from '../../../server/config/iConfig';
+export declare class RoomSettings implements iRoomDefaultSettings {
+    shortName: string;
+    defaultSettings: iRoomDefaultSettings;
+    private _lampenBeiBewegung;
+    private _lichtSonnenAufgangAus;
+    private _sonnenUntergangRollos;
+    private _sonnenAufgangRollos;
+    private _movementResetTimer;
+    private _sonnenUntergangRolloDelay;
+    private _sonnenUntergangRolloMaxTime;
+    private _sonnenUntergangLampenDelay;
+    private _sonnenAufgangRolloDelay;
+    private _sonnenAufgangRolloMinTime;
+    private _sonnenAufgangLampenDelay;
+    private _lightIfNoWindows;
+    hmIpSettings?: HmIpRoomSettings;
+    zigbeeSettings?: ZigbeeRoomSettings;
+    radioUrl: string;
+    etage: number;
+    rolloOffset: SunTimeOffsets;
+    lampOffset: SunTimeOffsets;
+    room?: RoomBase;
+    rolloHeatReduction: boolean;
+    constructor(shortName: string);
+    private recalcRolloOffset;
+    private recalcLampOffset;
+    get sonnenAufgangLampenDelay(): number;
+    set sonnenAufgangLampenDelay(value: number);
+    get sonnenAufgangRolloDelay(): number;
+    set sonnenAufgangRolloDelay(value: number);
+    get sonnenUntergangLampenDelay(): number;
+    set sonnenUntergangLampenDelay(value: number);
+    get sonnenUntergangRolloDelay(): number;
+    set sonnenUntergangRolloDelay(value: number);
+    get movementResetTimer(): number;
+    set movementResetTimer(value: number);
+    get lichtSonnenAufgangAus(): boolean;
+    get sonnenAufgangRollos(): boolean;
+    set sonnenAufgangRollos(value: boolean);
+    get sonnenUntergangRollos(): boolean;
+    set sonnenUntergangRollos(value: boolean);
+    set lichtSonnenAufgangAus(value: boolean);
+    get lampenBeiBewegung(): boolean;
+    set lampenBeiBewegung(value: boolean);
+    get sonnenUntergangRolloMaxTime(): iTimePair;
+    set sonnenUntergangRolloMaxTime(value: iTimePair);
+    get sonnenAufgangRolloMinTime(): iTimePair;
+    set sonnenAufgangRolloMinTime(value: iTimePair);
+    get lightIfNoWindows(): boolean;
+    set lightIfNoWindows(value: boolean);
+}

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomSettings = void 0;
+const settings_service_1 = require("../../../server/services/settings-service");
+const time_callback_service_1 = require("../../../server/services/time-callback-service");
+class RoomSettings {
+    constructor(shortName) {
+        this.shortName = shortName;
+        this.defaultSettings = settings_service_1.SettingsService.settings.roomDefault;
+        this._lampenBeiBewegung = this.defaultSettings.lampenBeiBewegung;
+        this._lichtSonnenAufgangAus = this.defaultSettings.lichtSonnenAufgangAus;
+        this._sonnenUntergangRollos = this.defaultSettings.sonnenUntergangRollos;
+        this._sonnenAufgangRollos = this.defaultSettings.sonnenAufgangRollos;
+        this._movementResetTimer = this.defaultSettings.movementResetTimer;
+        this._sonnenUntergangRolloDelay = this.defaultSettings.sonnenUntergangRolloDelay;
+        this._sonnenUntergangRolloMaxTime = this.defaultSettings.sonnenUntergangRolloMaxTime;
+        this._sonnenUntergangLampenDelay = this.defaultSettings.sonnenUntergangLampenDelay;
+        this._sonnenAufgangRolloDelay = this.defaultSettings.sonnenAufgangRolloDelay;
+        this._sonnenAufgangRolloMinTime = this.defaultSettings.sonnenAufgangRolloMinTime;
+        this._sonnenAufgangLampenDelay = this.defaultSettings.sonnenAufgangLampenDelay;
+        this._lightIfNoWindows = this.defaultSettings.lightIfNoWindows;
+        this.radioUrl = 'https://hermes.bcs-systems.de/hitradio-rtl_top40_64k_aac'; // Radio RTL
+        this.etage = -1;
+        this.rolloHeatReduction = this.defaultSettings.rolloHeatReduction;
+        this.rolloOffset = new time_callback_service_1.SunTimeOffsets(this.sonnenAufgangRolloDelay, this.sonnenUntergangRolloDelay, this.sonnenAufgangRolloMinTime.hours, this.sonnenAufgangRolloMinTime.minutes, this.sonnenUntergangRolloMaxTime.hours, this.sonnenUntergangRolloMaxTime.minutes);
+        this.lampOffset = new time_callback_service_1.SunTimeOffsets(this.sonnenAufgangLampenDelay, this.sonnenUntergangLampenDelay);
+    }
+    recalcRolloOffset() {
+        this.rolloOffset = new time_callback_service_1.SunTimeOffsets(this.sonnenAufgangRolloDelay, this.sonnenUntergangRolloDelay, this.sonnenAufgangRolloMinTime.hours, this.sonnenAufgangRolloMinTime.minutes, this.sonnenUntergangRolloMaxTime.hours, this.sonnenUntergangRolloMaxTime.minutes);
+        if (this.room) {
+            this.room.recalcTimeCallbacks();
+        }
+    }
+    recalcLampOffset() {
+        this.lampOffset = new time_callback_service_1.SunTimeOffsets(this.sonnenAufgangLampenDelay, this.sonnenAufgangRolloDelay);
+        if (this.room) {
+            this.room.recalcTimeCallbacks();
+        }
+    }
+    get sonnenAufgangLampenDelay() {
+        return this._sonnenAufgangLampenDelay;
+    }
+    set sonnenAufgangLampenDelay(value) {
+        this._sonnenAufgangLampenDelay = value;
+        this.recalcLampOffset();
+    }
+    get sonnenAufgangRolloDelay() {
+        return this._sonnenAufgangRolloDelay;
+    }
+    set sonnenAufgangRolloDelay(value) {
+        this._sonnenAufgangRolloDelay = value;
+        this.recalcRolloOffset();
+    }
+    get sonnenUntergangLampenDelay() {
+        return this._sonnenUntergangLampenDelay;
+    }
+    set sonnenUntergangLampenDelay(value) {
+        this._sonnenUntergangLampenDelay = value;
+        this.recalcLampOffset();
+    }
+    get sonnenUntergangRolloDelay() {
+        return this._sonnenUntergangRolloDelay;
+    }
+    set sonnenUntergangRolloDelay(value) {
+        this._sonnenUntergangRolloDelay = value;
+    }
+    get movementResetTimer() {
+        return this._movementResetTimer;
+    }
+    set movementResetTimer(value) {
+        this._movementResetTimer = value;
+    }
+    get lichtSonnenAufgangAus() {
+        return this._lichtSonnenAufgangAus;
+    }
+    get sonnenAufgangRollos() {
+        return this._sonnenAufgangRollos;
+    }
+    set sonnenAufgangRollos(value) {
+        this._sonnenAufgangRollos = value;
+        this.recalcRolloOffset();
+    }
+    get sonnenUntergangRollos() {
+        return this._sonnenUntergangRollos;
+    }
+    set sonnenUntergangRollos(value) {
+        this._sonnenUntergangRollos = value;
+        this.recalcRolloOffset();
+    }
+    set lichtSonnenAufgangAus(value) {
+        this._lichtSonnenAufgangAus = value;
+    }
+    get lampenBeiBewegung() {
+        return this._lampenBeiBewegung;
+    }
+    set lampenBeiBewegung(value) {
+        this._lampenBeiBewegung = value;
+    }
+    get sonnenUntergangRolloMaxTime() {
+        return this._sonnenUntergangRolloMaxTime;
+    }
+    set sonnenUntergangRolloMaxTime(value) {
+        this._sonnenUntergangRolloMaxTime = value;
+        this.recalcRolloOffset();
+    }
+    get sonnenAufgangRolloMinTime() {
+        return this._sonnenAufgangRolloMinTime;
+    }
+    set sonnenAufgangRolloMinTime(value) {
+        this._sonnenAufgangRolloMinTime = value;
+        this.recalcRolloOffset();
+    }
+    get lightIfNoWindows() {
+        return this._lightIfNoWindows;
+    }
+    set lightIfNoWindows(value) {
+        this._lightIfNoWindows = value;
+    }
+}
+exports.RoomSettings = RoomSettings;

package/lib/models/rooms/RoomSettings/hmIPRoomSettings.d.ts

@@ -0,0 +1,17 @@
+import { HmIpDeviceType } from '../../../server/devices/hmIPDevices/hmIpDeviceType';
+export declare class HmIpAddDeviceItem {
+    setID: (value: string) => void;
+    index: number;
+    customName: string;
+    private _added;
+    get added(): boolean;
+    set added(value: boolean);
+    constructor(setID: (value: string) => void, index: number, customName: string);
+}
+export declare class HmIpRoomSettings {
+    RoomName: string;
+    devices: Array<Array<HmIpAddDeviceItem>>;
+    constructor(RoomName: string);
+    addDevice(deviceType: HmIpDeviceType, setID: (value: string) => void, index: number, customName?: string | undefined): void;
+    checkMissing(): void;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmIpRoomSettings = exports.HmIpAddDeviceItem = void 0;
+const hmIpDeviceType_1 = require("../../../server/devices/hmIPDevices/hmIpDeviceType");
+const log_service_1 = require("../../../server/services/log-service");
+const logLevel_1 = require("../../logLevel");
+class HmIpAddDeviceItem {
+    constructor(setID, index, customName) {
+        this.setID = setID;
+        this.index = index;
+        this.customName = customName;
+        this._added = false;
+    }
+    get added() {
+        return this._added;
+    }
+    set added(value) {
+        if (this._added) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `${this.customName} Added twice`);
+        }
+        this._added = value;
+    }
+}
+exports.HmIpAddDeviceItem = HmIpAddDeviceItem;
+class HmIpRoomSettings {
+    constructor(RoomName) {
+        this.RoomName = RoomName;
+        this.devices = [];
+    }
+    addDevice(deviceType, setID, index, customName = undefined) {
+        if (this.devices[deviceType] === undefined) {
+            this.devices[deviceType] = [];
+        }
+        if (customName === undefined) {
+            customName = `${this.RoomName} ${hmIpDeviceType_1.HmIpDeviceType[deviceType]}`;
+        }
+        this.devices[deviceType][index] = new HmIpAddDeviceItem(setID, index, customName);
+    }
+    checkMissing() {
+        for (const type in this.devices) {
+            const devs = this.devices[type];
+            for (const index in devs) {
+                const dev = devs[index];
+                if (!dev.added) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `${dev.customName} fehlt in der Device JSON`);
+                }
+            }
+        }
+    }
+}
+exports.HmIpRoomSettings = HmIpRoomSettings;

package/lib/models/rooms/RoomSettings/iRoomDefaultSettings.d.ts

@@ -0,0 +1,16 @@
+import { iTimePair } from '../../../server/config/iConfig';
+export interface iRoomDefaultSettings {
+    rolloHeatReduction: boolean;
+    lampenBeiBewegung: boolean;
+    lichtSonnenAufgangAus: boolean;
+    sonnenUntergangRollos: boolean;
+    sonnenUntergangRolloDelay: number;
+    sonnenUntergangRolloMaxTime: iTimePair;
+    sonnenUntergangLampenDelay: number;
+    sonnenAufgangRollos: boolean;
+    sonnenAufgangRolloDelay: number;
+    sonnenAufgangRolloMinTime: iTimePair;
+    sonnenAufgangLampenDelay: number;
+    movementResetTimer: number;
+    lightIfNoWindows: boolean;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/rooms/RoomSettings/index.d.ts

@@ -0,0 +1,4 @@
+export * from './RoomSettings';
+export * from './hmIPRoomSettings';
+export * from './zigbeeRoomSettings';
+export * from './iRoomDefaultSettings';

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

@@ -0,0 +1,16 @@
+"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("./RoomSettings"), exports);
+__exportStar(require("./hmIPRoomSettings"), exports);
+__exportStar(require("./zigbeeRoomSettings"), exports);
+__exportStar(require("./iRoomDefaultSettings"), exports);

package/lib/models/rooms/RoomSettings/zigbeeRoomSettings.d.ts

@@ -0,0 +1,17 @@
+import { ZigbeeDeviceType } from '../../../server/devices/zigbee/zigbeeDeviceType';
+export declare class ZigbeeAddDeviceItem {
+    setID: (value: string) => void;
+    index: number;
+    customName: string;
+    private _added;
+    get added(): boolean;
+    set added(value: boolean);
+    constructor(setID: (value: string) => void, index: number, customName: string);
+}
+export declare class ZigbeeRoomSettings {
+    RoomName: string;
+    devices: Array<Array<ZigbeeAddDeviceItem>>;
+    constructor(RoomName: string);
+    addDevice(deviceType: ZigbeeDeviceType, setID: (value: string) => void, index: number, customName?: string | undefined): void;
+    checkMissing(): void;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeRoomSettings = exports.ZigbeeAddDeviceItem = void 0;
+const zigbeeDeviceType_1 = require("../../../server/devices/zigbee/zigbeeDeviceType");
+const log_service_1 = require("../../../server/services/log-service");
+const logLevel_1 = require("../../logLevel");
+class ZigbeeAddDeviceItem {
+    constructor(setID, index, customName) {
+        this.setID = setID;
+        this.index = index;
+        this.customName = customName;
+        this._added = false;
+    }
+    get added() {
+        return this._added;
+    }
+    set added(value) {
+        if (this._added) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `${this.customName} Added twice`);
+        }
+        this._added = value;
+    }
+}
+exports.ZigbeeAddDeviceItem = ZigbeeAddDeviceItem;
+class ZigbeeRoomSettings {
+    constructor(RoomName) {
+        this.RoomName = RoomName;
+        this.devices = [];
+    }
+    addDevice(deviceType, setID, index, customName = undefined) {
+        if (this.devices[deviceType] === undefined) {
+            this.devices[deviceType] = [];
+        }
+        if (customName === undefined) {
+            customName = `${this.RoomName} ${zigbeeDeviceType_1.ZigbeeDeviceType[deviceType]}`;
+        }
+        this.devices[deviceType][index] = new ZigbeeAddDeviceItem(setID, index, customName);
+    }
+    checkMissing() {
+        for (const type in this.devices) {
+            const devs = this.devices[type];
+            for (const index in devs) {
+                const dev = devs[index];
+                if (!dev.added) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `${dev.customName} fehlt in der Device JSON`);
+                }
+            }
+        }
+    }
+}
+exports.ZigbeeRoomSettings = ZigbeeRoomSettings;

package/{models/rooms/iRoomImportEnforcer.ts → lib/models/rooms/iRoomImportEnforcer.d.ts}

@@ -1,3 +1,3 @@
 export interface iRoomImportEnforcer {
-  addRoomConstructor(): void;
+    addRoomConstructor(): void;
 }