hoffmation-base 1.3.14-alpha.0 → 1.3.14-alpha.2

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

@@ -1,9 +1,7 @@
-import { iBaseDevice } from '../../server';
 import { ExcessEnergyConsumerSettings } from '../excessEnergyConsumerSettings';
-export declare abstract class DeviceSettings {
+import { ObjectSettings } from '../objectSettings';
+export declare abstract class DeviceSettings extends ObjectSettings {
     energySettings: ExcessEnergyConsumerSettings | undefined;
-    persist(device: iBaseDevice): void;
-    initializeFromDb(device: iBaseDevice): void;
     fromPartialObject(_obj: Partial<DeviceSettings>): void;
     protected toJSON(): Partial<DeviceSettings>;
 }

package/lib/models/deviceSettings/deviceSettings.js

@@ -1,40 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceSettings = void 0;
-const server_1 = require("../../server");
-const logLevel_1 = require("../logLevel");
 const excessEnergyConsumerSettings_1 = require("../excessEnergyConsumerSettings");
-class DeviceSettings {
+const objectSettings_1 = require("../objectSettings");
+const server_1 = require("../../server");
+class DeviceSettings extends objectSettings_1.ObjectSettings {
     constructor() {
+        super(...arguments);
         this.energySettings = undefined;
     }
-    persist(device) {
-        var _a;
-        (_a = server_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistSettings(device.id, JSON.stringify(this), device.info.customName);
-    }
-    initializeFromDb(device) {
-        var _a;
-        (_a = server_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.loadSettings(device.id).then((data) => {
-            if (!data) {
-                // Nothing in db yet
-                return;
-            }
-            let obj = null;
-            try {
-                obj = JSON.parse(data);
-            }
-            catch (e) {
-                device.log(logLevel_1.LogLevel.Error, `Failed to parse Device Setting JSON (${e})`);
-            }
-            if (!obj) {
-                return;
-            }
-            this.fromPartialObject(obj);
-            if (JSON.stringify(this) !== data) {
-                this.persist(device);
-            }
-        });
-    }
     fromPartialObject(_obj) {
         if (_obj.energySettings) {
             if (this.energySettings === undefined) {
@@ -42,6 +16,7 @@ class DeviceSettings {
             }
             this.energySettings.fromPartialObject(_obj.energySettings);
         }
+        super.fromPartialObject(_obj);
     }
     toJSON() {
         return server_1.Utils.jsonFilter(this);

package/lib/models/iIdHolder.d.ts

@@ -0,0 +1,6 @@
+import { LogLevel } from './logLevel';
+export interface iIdHolder {
+    readonly id: string;
+    readonly customName: string;
+    log(level: LogLevel, message: string): void;
+}

package/lib/models/iIdHolder.js

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

package/lib/models/index.d.ts

@@ -8,5 +8,6 @@ export * from './deviceConfig';
 export * from './excessEnergyConsumerSettings';
 export * from './iTemperaturDataPoint';
 export * from './logLevel';
+export * from './objectSettings';
 export * from './temperatureSettings';
 export * from './timeCallback';

package/lib/models/index.js

@@ -24,5 +24,6 @@ __exportStar(require("./deviceConfig"), exports);
 __exportStar(require("./excessEnergyConsumerSettings"), exports);
 __exportStar(require("./iTemperaturDataPoint"), exports);
 __exportStar(require("./logLevel"), exports);
+__exportStar(require("./objectSettings"), exports);
 __exportStar(require("./temperatureSettings"), exports);
 __exportStar(require("./timeCallback"), exports);

package/lib/models/objectSettings.d.ts

@@ -0,0 +1,8 @@
+import { iIdHolder } from './iIdHolder';
+export declare abstract class ObjectSettings {
+    onChangeCb?: () => void;
+    persist(holder: iIdHolder): void;
+    initializeFromDb(holder: iIdHolder): void;
+    fromPartialObject(_obj: Partial<ObjectSettings>): void;
+    protected toJSON(): Partial<ObjectSettings>;
+}

package/lib/models/objectSettings.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectSettings = void 0;
+const server_1 = require("../server");
+const logLevel_1 = require("./logLevel");
+class ObjectSettings {
+    persist(holder) {
+        var _a;
+        (_a = server_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistSettings(holder.id, JSON.stringify(this), holder.customName);
+    }
+    initializeFromDb(holder) {
+        var _a;
+        (_a = server_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.loadSettings(holder.id).then((data) => {
+            if (!data) {
+                // Nothing in db yet
+                return;
+            }
+            let obj = null;
+            try {
+                obj = JSON.parse(data);
+            }
+            catch (e) {
+                holder.log(logLevel_1.LogLevel.Error, `Failed to parse Device Setting JSON (${e})`);
+            }
+            if (!obj) {
+                return;
+            }
+            this.fromPartialObject(obj);
+            if (JSON.stringify(this) !== data) {
+                this.persist(holder);
+            }
+        });
+    }
+    fromPartialObject(_obj) {
+        // nothing yet
+    }
+    toJSON() {
+        return server_1.Utils.jsonFilter(this);
+    }
+}
+exports.ObjectSettings = ObjectSettings;

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

@@ -1,10 +1,11 @@
 import { TimeCallback } from '../timeCallback';
 import { BaseGroup, DeviceCluster, GroupType, HeatGroup, LampenGroup, PraesenzGroup, SmokeGroup, SpeakerGroup, TasterGroup, WaterGroup, WindowGroup } from '../../server';
-import { RoomSettings } from './RoomSettings';
+import { LogLevel } from '../logLevel';
+import { RoomSettingsController } from './RoomSettings';
 import { iRoomBase } from './iRoomBase';
 import { RoomInfo } from './roomInfo';
-export declare class RoomBase implements iRoomBase {
-    settings: RoomSettings;
+import { iIdHolder } from '../iIdHolder';
+export declare class RoomBase implements iRoomBase, iIdHolder {
     groupMap: Map<GroupType, BaseGroup>;
     info: RoomInfo;
     sonnenAufgangCallback: TimeCallback | undefined;
@@ -12,7 +13,14 @@ export declare class RoomBase implements iRoomBase {
     sonnenAufgangLichtCallback: TimeCallback | undefined;
     sonnenUntergangLichtCallback: TimeCallback | undefined;
     skipNextRolloUp: boolean;
-    constructor(roomName: string, settings: RoomSettings, groupMap: Map<GroupType, BaseGroup>);
+    settings: RoomSettingsController;
+    constructor(groupMap: Map<GroupType, BaseGroup>, roomName: string, etage?: number);
+    /**
+     * For Rooms the id is itss name
+     * @returns {string} The Roomname
+     */
+    get id(): string;
+    get customName(): string;
     protected _deviceCluster: DeviceCluster;
     get deviceCluster(): DeviceCluster;
     get WindowGroup(): WindowGroup | undefined;
@@ -39,5 +47,5 @@ export declare class RoomBase implements iRoomBase {
             [p: string]: BaseGroup;
         };
     }>;
-    private log;
+    log(level: LogLevel, message: string): void;
 }

package/lib/models/rooms/RoomBase.js

@@ -7,19 +7,28 @@ exports.RoomBase = void 0;
 const timeCallback_1 = require("../timeCallback");
 const server_1 = require("../../server");
 const logLevel_1 = require("../logLevel");
+const RoomSettings_1 = require("./RoomSettings");
 const roomInfo_1 = require("./roomInfo");
 const lodash_1 = __importDefault(require("lodash"));
 class RoomBase {
-    constructor(roomName, settings, groupMap) {
-        this.settings = settings;
+    constructor(groupMap, roomName, etage = 99) {
         this.groupMap = groupMap;
         this.skipNextRolloUp = false;
         this._deviceCluster = new server_1.DeviceCluster();
-        this.info = new roomInfo_1.RoomInfo(roomName, settings);
-        settings.roomName = roomName;
-        this.settings = settings;
+        this.info = new roomInfo_1.RoomInfo(roomName, etage);
+        this.settings = new RoomSettings_1.RoomSettingsController(this);
         server_1.RoomService.addToRoomList(this);
     }
+    /**
+     * For Rooms the id is itss name
+     * @returns {string} The Roomname
+     */
+    get id() {
+        return this.roomName;
+    }
+    get customName() {
+        return this.roomName;
+    }
     get deviceCluster() {
         return this._deviceCluster;
     }

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

@@ -2,8 +2,7 @@ import { iRoomInitializationSettings } from './iRoomInitializationSettings';
 import { RoomDeviceAddingSettings } from './roomDeviceAddingSettings';
 export declare class RoomInitializationSettings implements iRoomInitializationSettings {
     shortName: string;
-    etage: number;
     deviceAddidngSettings?: RoomDeviceAddingSettings;
-    constructor(shortName: string, etage?: number);
+    constructor(shortName: string);
     static registerRoomForDevices(roomInitializationSettings: RoomInitializationSettings): void;
 }

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

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoomInitializationSettings = void 0;
 const server_1 = require("../../../server");
 class RoomInitializationSettings {
-    constructor(shortName, etage = -1) {
+    constructor(shortName) {
         this.shortName = shortName;
-        this.etage = etage;
     }
     static registerRoomForDevices(roomInitializationSettings) {
         if (roomInitializationSettings.deviceAddidngSettings !== undefined) {

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

@@ -0,0 +1,34 @@
+import { RoomBase } from '../RoomBase';
+import { iRoomDefaultSettings } from './iRoomDefaultSettings';
+import { iTimePair, SunTimeOffsets } from '../../../server';
+import { RoomSettings } from './roomSettings';
+export declare class RoomSettingsController implements iRoomDefaultSettings {
+    constructor(room: RoomBase);
+    roomName: string;
+    rolloOffset: SunTimeOffsets;
+    lampOffset: SunTimeOffsets;
+    private _settingsContainer;
+    get settingsContainer(): RoomSettings;
+    get lichtSonnenAufgangAus(): boolean;
+    get ambientLightAfterSunset(): boolean;
+    get rolloHeatReduction(): boolean;
+    get sonnenAufgangRollos(): boolean;
+    get sonnenUntergangRolloMaxTime(): iTimePair;
+    get sonnenAufgangRolloMinTime(): iTimePair;
+    get lightIfNoWindows(): boolean;
+    get lampenBeiBewegung(): boolean;
+    get sonnenUntergangRollos(): boolean;
+    get movementResetTimer(): number;
+    get sonnenUntergangRolloDelay(): number;
+    get sonnenUntergangLampenDelay(): number;
+    get sonnenUntergangRolloAdditionalOffsetPerCloudiness(): number;
+    get sonnenAufgangRolloDelay(): number;
+    get sonnenAufgangLampenDelay(): number;
+    get roomIsAlwaysDark(): boolean;
+    get radioUrl(): string;
+    get room(): RoomBase | undefined;
+    toJSON(): Partial<RoomSettingsController>;
+    private onSettingChange;
+    private recalcRolloOffset;
+    private recalcLampOffset;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomSettingsController = void 0;
+const server_1 = require("../../../server");
+const lodash_1 = __importDefault(require("lodash"));
+const roomSettings_1 = require("./roomSettings");
+class RoomSettingsController {
+    constructor(room) {
+        this._settingsContainer = new roomSettings_1.RoomSettings();
+        this.roomName = room.roomName;
+        this.rolloOffset = new server_1.SunTimeOffsets(this.sonnenAufgangRolloDelay, this.sonnenUntergangRolloDelay, this.sonnenAufgangRolloMinTime.hours, this.sonnenAufgangRolloMinTime.minutes, this.sonnenUntergangRolloMaxTime.hours, this.sonnenUntergangRolloMaxTime.minutes);
+        this.lampOffset = new server_1.SunTimeOffsets(this.sonnenAufgangLampenDelay, this.sonnenUntergangLampenDelay);
+        this._settingsContainer.onChangeCb = this.onSettingChange.bind(this);
+        this._settingsContainer.initializeFromDb(room);
+    }
+    get settingsContainer() {
+        return this._settingsContainer;
+    }
+    get lichtSonnenAufgangAus() {
+        return this._settingsContainer.lichtSonnenAufgangAus;
+    }
+    get ambientLightAfterSunset() {
+        return this._settingsContainer.ambientLightAfterSunset;
+    }
+    get rolloHeatReduction() {
+        return this._settingsContainer.rolloHeatReduction;
+    }
+    get sonnenAufgangRollos() {
+        return this._settingsContainer.sonnenAufgangRollos;
+    }
+    get sonnenUntergangRolloMaxTime() {
+        return this._settingsContainer.sonnenUntergangRolloMaxTime;
+    }
+    get sonnenAufgangRolloMinTime() {
+        return this._settingsContainer.sonnenAufgangRolloMinTime;
+    }
+    get lightIfNoWindows() {
+        return this._settingsContainer.lightIfNoWindows;
+    }
+    get lampenBeiBewegung() {
+        return this._settingsContainer.lampenBeiBewegung;
+    }
+    get sonnenUntergangRollos() {
+        return this._settingsContainer.sonnenUntergangRollos;
+    }
+    get movementResetTimer() {
+        return this._settingsContainer.movementResetTimer;
+    }
+    get sonnenUntergangRolloDelay() {
+        return this._settingsContainer.sonnenUntergangRolloDelay;
+    }
+    get sonnenUntergangLampenDelay() {
+        return this._settingsContainer.sonnenUntergangLampenDelay;
+    }
+    get sonnenUntergangRolloAdditionalOffsetPerCloudiness() {
+        return this._settingsContainer.sonnenUntergangRolloAdditionalOffsetPerCloudiness;
+    }
+    get sonnenAufgangRolloDelay() {
+        return this._settingsContainer.sonnenAufgangRolloDelay;
+    }
+    get sonnenAufgangLampenDelay() {
+        return this._settingsContainer.sonnenAufgangLampenDelay;
+    }
+    get roomIsAlwaysDark() {
+        return this._settingsContainer.roomIsAlwaysDark;
+    }
+    get radioUrl() {
+        return this._settingsContainer.radioUrl;
+    }
+    get room() {
+        if (!this.roomName) {
+            return undefined;
+        }
+        return server_1.API.getRoom(this.roomName);
+    }
+    toJSON() {
+        const result = server_1.Utils.jsonFilter(this);
+        return lodash_1.default.omit(result, [`defaultSettings`, 'deviceAddidngSettings']);
+    }
+    onSettingChange() {
+        this.recalcLampOffset();
+        this.recalcRolloOffset();
+    }
+    recalcRolloOffset() {
+        var _a;
+        this.rolloOffset = new server_1.SunTimeOffsets(this.sonnenAufgangRolloDelay, this.sonnenUntergangRolloDelay, this.sonnenAufgangRolloMinTime.hours, this.sonnenAufgangRolloMinTime.minutes, this.sonnenUntergangRolloMaxTime.hours, this.sonnenUntergangRolloMaxTime.minutes);
+        if (this.sonnenUntergangRolloAdditionalOffsetPerCloudiness > 0) {
+            server_1.WeatherService.addWeatherUpdateCb(`RolloWeatherUpdate${this.roomName}`, () => {
+                var _a;
+                (_a = this.room) === null || _a === void 0 ? void 0 : _a.recalcTimeCallbacks();
+            });
+        }
+        (_a = this.room) === null || _a === void 0 ? void 0 : _a.recalcTimeCallbacks();
+    }
+    recalcLampOffset() {
+        var _a;
+        this.lampOffset = new server_1.SunTimeOffsets(this.sonnenAufgangLampenDelay, this.sonnenUntergangLampenDelay);
+        (_a = this.room) === null || _a === void 0 ? void 0 : _a.recalcTimeCallbacks();
+    }
+}
+exports.RoomSettingsController = RoomSettingsController;

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

@@ -1,23 +1,27 @@
 import { iTimePair } from '../../../server';
 export interface iRoomDefaultSettings {
-    rolloHeatReduction: boolean;
+    /**
+     * The default radio URL to use with speaker
+     */
+    readonly radioUrl?: string;
+    readonly rolloHeatReduction: boolean;
     /**
      * Indicates rooms, which are time independent always dark (like basement).
      * This results in lamps beeing turned on on motion regardless of windows and time.
      */
-    roomIsAlwaysDark: boolean;
-    lampenBeiBewegung: boolean;
-    lichtSonnenAufgangAus: boolean;
-    sonnenUntergangRollos: boolean;
-    sonnenUntergangRolloDelay: number;
-    sonnenUntergangRolloMaxTime: iTimePair;
-    sonnenUntergangLampenDelay: number;
-    sonnenUntergangRolloAdditionalOffsetPerCloudiness: number;
-    sonnenAufgangRollos: boolean;
-    sonnenAufgangRolloDelay: number;
-    sonnenAufgangRolloMinTime: iTimePair;
-    sonnenAufgangLampenDelay: number;
-    movementResetTimer: number;
-    lightIfNoWindows: boolean;
-    ambientLightAfterSunset: boolean;
+    readonly roomIsAlwaysDark: boolean;
+    readonly lampenBeiBewegung: boolean;
+    readonly lichtSonnenAufgangAus: boolean;
+    readonly sonnenUntergangRollos: boolean;
+    readonly sonnenUntergangRolloDelay: number;
+    readonly sonnenUntergangRolloMaxTime: iTimePair;
+    readonly sonnenUntergangLampenDelay: number;
+    readonly sonnenUntergangRolloAdditionalOffsetPerCloudiness: number;
+    readonly sonnenAufgangRollos: boolean;
+    readonly sonnenAufgangRolloDelay: number;
+    readonly sonnenAufgangRolloMinTime: iTimePair;
+    readonly sonnenAufgangLampenDelay: number;
+    readonly movementResetTimer: number;
+    readonly lightIfNoWindows: boolean;
+    readonly ambientLightAfterSunset: boolean;
 }

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

@@ -1,6 +1,5 @@
 import { RoomDeviceAddingSettings } from './roomDeviceAddingSettings';
 export interface iRoomInitializationSettings {
     deviceAddidngSettings?: RoomDeviceAddingSettings;
-    etage: number;
     shortName: string;
 }

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

@@ -3,4 +3,5 @@ export * from './iRoomInitializationSettings';
 export * from './roomAddDeviceItem';
 export * from './roomDeviceAddingSettings';
 export * from './RoomInitializationSettings';
-export * from './RoomSettings';
+export * from './roomSettings';
+export * from './RoomSettingsController';

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

@@ -19,4 +19,5 @@ __exportStar(require("./iRoomInitializationSettings"), exports);
 __exportStar(require("./roomAddDeviceItem"), exports);
 __exportStar(require("./roomDeviceAddingSettings"), exports);
 __exportStar(require("./RoomInitializationSettings"), exports);
-__exportStar(require("./RoomSettings"), exports);
+__exportStar(require("./roomSettings"), exports);
+__exportStar(require("./RoomSettingsController"), exports);

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

@@ -0,0 +1,39 @@
+import { ObjectSettings } from '../../objectSettings';
+import { iTimePair } from '../../../server';
+export declare class RoomSettings extends ObjectSettings {
+    private _ambientLightAfterSunset;
+    get ambientLightAfterSunset(): boolean;
+    private _lichtSonnenAufgangAus;
+    get lichtSonnenAufgangAus(): boolean;
+    private _radioUrl;
+    get radioUrl(): string;
+    private _rolloHeatReduction;
+    get rolloHeatReduction(): boolean;
+    private _lampenBeiBewegung;
+    get lampenBeiBewegung(): boolean;
+    private _lightIfNoWindows;
+    get lightIfNoWindows(): boolean;
+    private _movementResetTimer;
+    get movementResetTimer(): number;
+    private _roomIsAlwaysDark;
+    get roomIsAlwaysDark(): boolean;
+    private _sonnenAufgangLampenDelay;
+    get sonnenAufgangLampenDelay(): number;
+    private _sonnenAufgangRolloDelay;
+    get sonnenAufgangRolloDelay(): number;
+    private _sonnenAufgangRollos;
+    get sonnenAufgangRollos(): boolean;
+    private _sonnenUntergangRolloAdditionalOffsetPerCloudiness;
+    get sonnenUntergangRolloAdditionalOffsetPerCloudiness(): number;
+    private _sonnenUntergangRolloMaxTime;
+    get sonnenUntergangRolloMaxTime(): iTimePair;
+    private _sonnenAufgangRolloMinTime;
+    get sonnenAufgangRolloMinTime(): iTimePair;
+    private _sonnenUntergangRolloDelay;
+    get sonnenUntergangRolloDelay(): number;
+    private _sonnenUntergangLampenDelay;
+    get sonnenUntergangLampenDelay(): number;
+    private _sonnenUntergangRollos;
+    get sonnenUntergangRollos(): boolean;
+    fromPartialObject(_obj: Partial<RoomSettings>): void;
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomSettings = void 0;
+const objectSettings_1 = require("../../objectSettings");
+const server_1 = require("../../../server");
+class RoomSettings extends objectSettings_1.ObjectSettings {
+    constructor() {
+        var _a;
+        super(...arguments);
+        this._ambientLightAfterSunset = server_1.SettingsService.settings.roomDefault.ambientLightAfterSunset;
+        this._lichtSonnenAufgangAus = server_1.SettingsService.settings.roomDefault.lichtSonnenAufgangAus;
+        this._radioUrl = (_a = server_1.SettingsService.settings.roomDefault.radioUrl) !== null && _a !== void 0 ? _a : '';
+        this._rolloHeatReduction = server_1.SettingsService.settings.roomDefault.rolloHeatReduction;
+        this._lampenBeiBewegung = server_1.SettingsService.settings.roomDefault.lampenBeiBewegung;
+        this._lightIfNoWindows = server_1.SettingsService.settings.roomDefault.lightIfNoWindows;
+        this._movementResetTimer = server_1.SettingsService.settings.roomDefault.movementResetTimer;
+        this._roomIsAlwaysDark = server_1.SettingsService.settings.roomDefault.roomIsAlwaysDark;
+        this._sonnenAufgangLampenDelay = server_1.SettingsService.settings.roomDefault.sonnenAufgangLampenDelay;
+        this._sonnenAufgangRolloDelay = server_1.SettingsService.settings.roomDefault.sonnenAufgangRolloDelay;
+        this._sonnenAufgangRollos = server_1.SettingsService.settings.roomDefault.sonnenAufgangRollos;
+        this._sonnenUntergangRolloAdditionalOffsetPerCloudiness = server_1.SettingsService.settings.roomDefault.sonnenUntergangRolloAdditionalOffsetPerCloudiness;
+        this._sonnenUntergangRolloMaxTime = server_1.SettingsService.settings.roomDefault.sonnenUntergangRolloMaxTime;
+        this._sonnenAufgangRolloMinTime = server_1.SettingsService.settings.roomDefault.sonnenAufgangRolloMinTime;
+        this._sonnenUntergangRolloDelay = server_1.SettingsService.settings.roomDefault.sonnenUntergangRolloDelay;
+        this._sonnenUntergangLampenDelay = server_1.SettingsService.settings.roomDefault.sonnenUntergangLampenDelay;
+        this._sonnenUntergangRollos = server_1.SettingsService.settings.roomDefault.sonnenUntergangRollos;
+    }
+    get ambientLightAfterSunset() {
+        return this._ambientLightAfterSunset;
+    }
+    get lichtSonnenAufgangAus() {
+        return this._lichtSonnenAufgangAus;
+    }
+    get radioUrl() {
+        return this._radioUrl;
+    }
+    get rolloHeatReduction() {
+        return this._rolloHeatReduction;
+    }
+    get lampenBeiBewegung() {
+        return this._lampenBeiBewegung;
+    }
+    get lightIfNoWindows() {
+        return this._lightIfNoWindows;
+    }
+    get movementResetTimer() {
+        return this._movementResetTimer;
+    }
+    get roomIsAlwaysDark() {
+        return this._roomIsAlwaysDark;
+    }
+    get sonnenAufgangLampenDelay() {
+        return this._sonnenAufgangLampenDelay;
+    }
+    get sonnenAufgangRolloDelay() {
+        return this._sonnenAufgangRolloDelay;
+    }
+    get sonnenAufgangRollos() {
+        return this._sonnenAufgangRollos;
+    }
+    get sonnenUntergangRolloAdditionalOffsetPerCloudiness() {
+        return this._sonnenUntergangRolloAdditionalOffsetPerCloudiness;
+    }
+    get sonnenUntergangRolloMaxTime() {
+        return this._sonnenUntergangRolloMaxTime;
+    }
+    get sonnenAufgangRolloMinTime() {
+        return this._sonnenAufgangRolloMinTime;
+    }
+    get sonnenUntergangRolloDelay() {
+        return this._sonnenUntergangRolloDelay;
+    }
+    get sonnenUntergangLampenDelay() {
+        return this._sonnenUntergangLampenDelay;
+    }
+    get sonnenUntergangRollos() {
+        return this._sonnenUntergangRollos;
+    }
+    fromPartialObject(_obj) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        this._ambientLightAfterSunset = (_a = _obj.ambientLightAfterSunset) !== null && _a !== void 0 ? _a : this.ambientLightAfterSunset;
+        this._lichtSonnenAufgangAus = (_b = _obj.lichtSonnenAufgangAus) !== null && _b !== void 0 ? _b : this.lichtSonnenAufgangAus;
+        this._radioUrl = (_c = _obj.radioUrl) !== null && _c !== void 0 ? _c : this.radioUrl;
+        this._rolloHeatReduction = (_d = _obj.rolloHeatReduction) !== null && _d !== void 0 ? _d : this.rolloHeatReduction;
+        this._lampenBeiBewegung = (_e = _obj.lampenBeiBewegung) !== null && _e !== void 0 ? _e : this.lampenBeiBewegung;
+        this._lightIfNoWindows = (_f = _obj.lightIfNoWindows) !== null && _f !== void 0 ? _f : this.lightIfNoWindows;
+        this._movementResetTimer = (_g = _obj.movementResetTimer) !== null && _g !== void 0 ? _g : this.movementResetTimer;
+        this._roomIsAlwaysDark = (_h = _obj.roomIsAlwaysDark) !== null && _h !== void 0 ? _h : this.roomIsAlwaysDark;
+        this._sonnenAufgangLampenDelay = (_j = _obj.sonnenAufgangLampenDelay) !== null && _j !== void 0 ? _j : this.sonnenAufgangLampenDelay;
+        this._sonnenAufgangRolloDelay = (_k = _obj.sonnenAufgangRolloDelay) !== null && _k !== void 0 ? _k : this.sonnenAufgangRolloDelay;
+        this._sonnenAufgangRollos = (_l = _obj.sonnenAufgangRollos) !== null && _l !== void 0 ? _l : this.sonnenAufgangRollos;
+        this._sonnenUntergangRolloAdditionalOffsetPerCloudiness =
+            (_m = _obj.sonnenUntergangRolloAdditionalOffsetPerCloudiness) !== null && _m !== void 0 ? _m : this.sonnenUntergangRolloAdditionalOffsetPerCloudiness;
+        this._sonnenUntergangRolloMaxTime = (_o = _obj.sonnenUntergangRolloMaxTime) !== null && _o !== void 0 ? _o : this.sonnenUntergangRolloMaxTime;
+        this._sonnenAufgangRolloMinTime = (_p = _obj.sonnenAufgangRolloMinTime) !== null && _p !== void 0 ? _p : this.sonnenAufgangRolloMinTime;
+        this._sonnenUntergangRolloDelay = (_q = _obj.sonnenUntergangRolloDelay) !== null && _q !== void 0 ? _q : this.sonnenUntergangRolloDelay;
+        this._sonnenUntergangLampenDelay = (_r = _obj.sonnenUntergangLampenDelay) !== null && _r !== void 0 ? _r : this.sonnenUntergangLampenDelay;
+        this._sonnenUntergangRollos = (_s = _obj.sonnenUntergangRollos) !== null && _s !== void 0 ? _s : this.sonnenUntergangRollos;
+        super.fromPartialObject(_obj);
+    }
+}
+exports.RoomSettings = RoomSettings;

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

@@ -1,6 +1,5 @@
-import { RoomSettings } from './RoomSettings';
 export declare class RoomInfo {
     roomName: string;
-    etage?: number;
-    constructor(roomName: string, settings: RoomSettings);
+    etage: number;
+    constructor(roomName: string, etage?: number);
 }

package/lib/models/rooms/roomInfo.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoomInfo = void 0;
 class RoomInfo {
-    constructor(roomName, settings) {
+    constructor(roomName, etage = 99) {
         this.roomName = roomName;
-        this.etage = settings.etage;
+        this.etage = etage;
     }
 }
 exports.RoomInfo = RoomInfo;

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

@@ -15,6 +15,7 @@ export declare abstract class IoBrokerBaseDevice implements iRoomDevice {
     };
     room: RoomBase | undefined;
     readonly deviceCapabilities: DeviceCapability[];
+    get customName(): string;
     protected readonly individualStateCallbacks: Map<string, Array<(val: ioBroker.StateValue) => void>>;
     protected constructor(_info: IoBrokerDeviceInfo, deviceType: DeviceType);
     get id(): string;

package/lib/server/devices/IoBrokerBaseDevice.js

@@ -5,6 +5,9 @@ const services_1 = require("../services");
 const models_1 = require("../../models");
 const ioBroker_1 = require("../ioBroker");
 class IoBrokerBaseDevice {
+    get customName() {
+        return this.info.customName;
+    }
     constructor(_info, deviceType) {
         this._info = _info;
         this.deviceType = deviceType;

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

@@ -1,14 +1,13 @@
-import { DeviceSettings, LogLevel } from '../../../models';
+import { DeviceSettings } from '../../../models';
 import { DeviceType } from '../deviceType';
 import { DeviceInfo } from '../DeviceInfo';
 import { DeviceCapability } from '../DeviceCapability';
-export interface iBaseDevice {
+import { iIdHolder } from '../../../models/iIdHolder';
+export interface iBaseDevice extends iIdHolder {
     readonly settings: DeviceSettings | undefined;
     deviceType: DeviceType;
     info: DeviceInfo;
     readonly deviceCapabilities: DeviceCapability[];
-    readonly id: string;
-    log(level: LogLevel, message: string): void;
     persistDeviceInfo(): void;
     loadDeviceSettings(): void;
     toJSON(): Partial<iBaseDevice>;