hoffmation-base 2.0.1 → 2.0.2

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

@@ -8,13 +8,13 @@ import { iIdHolder } from '../iIdHolder';
 export declare class RoomBase implements iRoomBase, iIdHolder {
     groupMap: Map<GroupType, BaseGroup>;
     info: RoomInfo;
-    sonnenAufgangCallback: TimeCallback | undefined;
-    sonnenUntergangCallback: TimeCallback | undefined;
-    sonnenAufgangLichtCallback: TimeCallback | undefined;
-    sonnenUntergangLichtCallback: TimeCallback | undefined;
     skipNextRolloUp: boolean;
     settings: RoomSettingsController;
     constructor(groupMap: Map<GroupType, BaseGroup>, roomName: string, etage?: number);
+    get sonnenUntergangLichtCallback(): TimeCallback | undefined;
+    get sonnenAufgangLichtCallback(): TimeCallback | undefined;
+    get sunriseShutterCallback(): TimeCallback | undefined;
+    get sunsetShutterCallback(): TimeCallback | undefined;
     /**
      * For Rooms the id is itss name
      * @returns {string} The Roomname

package/lib/models/rooms/RoomBase.js

@@ -19,6 +19,22 @@ class RoomBase {
         this.settings = new RoomSettings_1.RoomSettingsController(this);
         server_1.RoomService.addToRoomList(this);
     }
+    get sonnenUntergangLichtCallback() {
+        var _a;
+        return (_a = this.LampenGroup) === null || _a === void 0 ? void 0 : _a.sonnenUntergangLichtCallback;
+    }
+    get sonnenAufgangLichtCallback() {
+        var _a;
+        return (_a = this.LampenGroup) === null || _a === void 0 ? void 0 : _a.sonnenAufgangLichtCallback;
+    }
+    get sunriseShutterCallback() {
+        var _a;
+        return (_a = this.WindowGroup) === null || _a === void 0 ? void 0 : _a.sunriseShutterCallback;
+    }
+    get sunsetShutterCallback() {
+        var _a;
+        return (_a = this.WindowGroup) === null || _a === void 0 ? void 0 : _a.sunsetShutterCallback;
+    }
     /**
      * For Rooms the id is itss name
      * @returns {string} The Roomname
@@ -63,56 +79,23 @@ class RoomBase {
         return this.info.etage;
     }
     initializeBase() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         this.log(logLevel_1.LogLevel.Debug, `RoomBase Init für ${this.roomName}`);
         this.recalcTimeCallbacks();
         (_a = this.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.initCallbacks();
         (_b = this.WindowGroup) === null || _b === void 0 ? void 0 : _b.initialize();
-        (_c = this.TasterGroup) === null || _c === void 0 ? void 0 : _c.initCallbacks();
-        (_d = this.HeatGroup) === null || _d === void 0 ? void 0 : _d.initialize();
-        if (this.settings.ambientLightAfterSunset && this.settings.lampOffset) {
-            const cb = new timeCallback_1.TimeCallback(`${this.roomName} Ambient Light after Sunset`, timeCallback_1.TimeCallbackType.SunSet, () => {
-                var _a;
-                this.log(logLevel_1.LogLevel.Info, `Draußen wird es dunkel --> Aktiviere Ambientenbeleuchtung`);
-                (_a = this.LampenGroup) === null || _a === void 0 ? void 0 : _a.switchAll(true);
-                server_1.Utils.guardedTimeout(() => {
-                    var _a;
-                    this.log(logLevel_1.LogLevel.Info, `Ambientenbeleuchtung um Mitternacht abschalten.`);
-                    (_a = this.LampenGroup) === null || _a === void 0 ? void 0 : _a.switchAll(false);
-                }, server_1.Utils.timeTilMidnight, this);
-            }, this.settings.lampOffset.sunset);
-            this.sonnenUntergangLichtCallback = cb;
-            server_1.TimeCallbackService.addCallback(cb);
-        }
+        (_c = this.LampenGroup) === null || _c === void 0 ? void 0 : _c.initialize();
+        (_d = this.TasterGroup) === null || _d === void 0 ? void 0 : _d.initCallbacks();
+        (_e = this.HeatGroup) === null || _e === void 0 ? void 0 : _e.initialize();
     }
     persist() {
         var _a;
         (_a = server_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addRoom(this);
     }
     recalcTimeCallbacks() {
-        const now = new Date();
-        if (this.sonnenAufgangCallback && this.settings.rolloOffset) {
-            this.sonnenAufgangCallback.minuteOffset = this.settings.rolloOffset.sunrise;
-            this.sonnenAufgangCallback.sunTimeOffset = this.settings.rolloOffset;
-            this.sonnenAufgangCallback.recalcNextToDo(now);
-        }
-        if (this.sonnenUntergangCallback && this.settings.rolloOffset) {
-            this.sonnenUntergangCallback.minuteOffset = this.settings.rolloOffset.sunset;
-            this.sonnenUntergangCallback.sunTimeOffset = this.settings.rolloOffset;
-            if (this.settings.sonnenUntergangRolloAdditionalOffsetPerCloudiness > 0) {
-                this.sonnenUntergangCallback.cloudOffset =
-                    server_1.WeatherService.getCurrentCloudiness() * this.settings.sonnenUntergangRolloAdditionalOffsetPerCloudiness;
-            }
-            this.sonnenUntergangCallback.recalcNextToDo(now);
-        }
-        if (this.sonnenAufgangLichtCallback && this.settings.lampOffset) {
-            this.sonnenAufgangLichtCallback.minuteOffset = this.settings.lampOffset.sunrise;
-            this.sonnenAufgangLichtCallback.recalcNextToDo(now);
-        }
-        if (this.sonnenUntergangLichtCallback && this.settings.lampOffset) {
-            this.sonnenUntergangLichtCallback.minuteOffset = this.settings.lampOffset.sunset;
-            this.sonnenUntergangLichtCallback.recalcNextToDo(now);
-        }
+        var _a, _b;
+        (_a = this.WindowGroup) === null || _a === void 0 ? void 0 : _a.recalcTimeCallbacks();
+        (_b = this.LampenGroup) === null || _b === void 0 ? void 0 : _b.recalcTimeCallbacks();
     }
     /**
      * Sets the light based on the current time, rollo Position and room Settings

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

@@ -1,7 +1,7 @@
 import { TimeCallback } from '../timeCallback';
 export interface iRoomBase {
-    sonnenAufgangCallback: TimeCallback | undefined;
-    sonnenUntergangCallback: TimeCallback | undefined;
+    sunriseShutterCallback: TimeCallback | undefined;
+    sunsetShutterCallback: TimeCallback | undefined;
     sonnenAufgangLichtCallback: TimeCallback | undefined;
     sonnenUntergangLichtCallback: TimeCallback | undefined;
     skipNextRolloUp: boolean;

package/lib/models/timeCallback.d.ts

@@ -13,7 +13,7 @@ export declare enum TimeOfDay {
 export declare class TimeCallback {
     name: string;
     type: TimeCallbackType;
-    cFunction: () => void;
+    private cFunction;
     minuteOffset: number;
     hours?: number | undefined;
     minutes?: number | undefined;
@@ -23,4 +23,5 @@ export declare class TimeCallback {
     nextToDo?: Date;
     constructor(name: string, type: TimeCallbackType, cFunction: () => void, minuteOffset: number, hours?: number | undefined, minutes?: number | undefined, sunTimeOffset?: SunTimeOffsets | undefined, cloudOffset?: number | undefined);
     recalcNextToDo(now: Date): void;
+    perform(): void;
 }

package/lib/models/timeCallback.js

@@ -84,5 +84,9 @@ class TimeCallback {
                 break;
         }
     }
+    perform() {
+        server_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Timecallback '${this.name}' fired`);
+        this.cFunction();
+    }
 }
 exports.TimeCallback = TimeCallback;

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

@@ -1,9 +1,11 @@
 import { BaseGroup } from './base-group';
 import { iActuator, iLamp } from '../baseDeviceInterfaces';
-import { TimeOfDay } from '../../../models';
+import { TimeCallback, TimeOfDay } from '../../../models';
 import { WledDevice } from '../wledDevice';
 import { iLedRgbCct } from '../baseDeviceInterfaces/iLedRgbCct';
 export declare class LampenGroup extends BaseGroup {
+    sonnenAufgangLichtCallback: TimeCallback | undefined;
+    sonnenUntergangLichtCallback: TimeCallback | undefined;
     constructor(roomName: string, lampenIds?: string[], steckerIds?: string[], ledIds?: string[], wledIds?: string[]);
     anyLightsOn(): boolean;
     getLampen(): iLamp[];
@@ -17,4 +19,9 @@ export declare class LampenGroup extends BaseGroup {
     setAllStecker(pValue: boolean, time?: TimeOfDay, force?: boolean): void;
     setAllLED(pValue: boolean, brightness?: number, color?: string, colortemp?: number): void;
     setAllWled(pValue: boolean, brightness?: number, preset?: number): void;
+    initialize(): void;
+    recalcTimeCallbacks(): void;
+    toJSON(): Partial<LampenGroup>;
+    private reconfigureSunriseTimeCallback;
+    private reconfigureSunsetTimeCallback;
 }

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

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LampenGroup = void 0;
 const services_1 = require("../../services");
@@ -7,6 +10,7 @@ const group_type_1 = require("./group-type");
 const device_cluster_type_1 = require("../device-cluster-type");
 const device_list_1 = require("../device-list");
 const models_1 = require("../../../models");
+const lodash_1 = __importDefault(require("lodash"));
 class LampenGroup extends base_group_1.BaseGroup {
     constructor(roomName, lampenIds = [], steckerIds = [], ledIds = [], wledIds = []) {
         super(roomName, group_type_1.GroupType.Light);
@@ -134,5 +138,66 @@ class LampenGroup extends base_group_1.BaseGroup {
             w.setWled(pValue, brightness, preset);
         });
     }
+    initialize() {
+        this.recalcTimeCallbacks();
+    }
+    recalcTimeCallbacks() {
+        this.reconfigureSunriseTimeCallback();
+        this.reconfigureSunsetTimeCallback();
+    }
+    toJSON() {
+        return services_1.Utils.jsonFilter(lodash_1.default.omit(this, ['_deviceCluster']));
+    }
+    reconfigureSunriseTimeCallback() {
+        const room = this.getRoom();
+        if (!room.settings.lichtSonnenAufgangAus || !room.settings.lampOffset) {
+            if (this.sonnenAufgangLichtCallback !== undefined) {
+                this.log(models_1.LogLevel.Trace, `Remove Sunrise Lamp callback for ${this.roomName}`);
+                services_1.TimeCallbackService.removeCallback(this.sonnenAufgangLichtCallback);
+                this.sonnenAufgangLichtCallback = undefined;
+            }
+            return;
+        }
+        if (this.sonnenAufgangLichtCallback && room.settings.lampOffset) {
+            this.sonnenAufgangLichtCallback.minuteOffset = room.settings.lampOffset.sunrise;
+            this.sonnenAufgangLichtCallback.recalcNextToDo(new Date());
+        }
+        if (this.sonnenAufgangLichtCallback === undefined) {
+            this.log(models_1.LogLevel.Trace, `Add Sunrise lamp TimeCallback for ${this.roomName}`);
+            const cb = new models_1.TimeCallback(`${this.roomName} Morgens Lampe aus`, models_1.TimeCallbackType.Sunrise, () => {
+                this.handleSunriseOff();
+            }, this.getRoom().settings.lampOffset.sunrise);
+            this.sonnenAufgangLichtCallback = cb;
+            services_1.TimeCallbackService.addCallback(cb);
+        }
+    }
+    reconfigureSunsetTimeCallback() {
+        const room = this.getRoom();
+        if (!room.settings.ambientLightAfterSunset || !room.settings.lampOffset) {
+            if (this.sonnenUntergangLichtCallback !== undefined) {
+                this.log(models_1.LogLevel.Trace, `Remove Sunset Lamp callback for ${this.roomName}`);
+                services_1.TimeCallbackService.removeCallback(this.sonnenUntergangLichtCallback);
+                this.sonnenUntergangLichtCallback = undefined;
+            }
+            return;
+        }
+        if (this.sonnenUntergangLichtCallback && room.settings.lampOffset) {
+            this.sonnenUntergangLichtCallback.minuteOffset = room.settings.lampOffset.sunset;
+            this.sonnenUntergangLichtCallback.recalcNextToDo(new Date());
+        }
+        if (this.sonnenUntergangLichtCallback === undefined) {
+            this.log(models_1.LogLevel.Trace, `Add Sunset Light TimeCallback for ${this.roomName}`);
+            const cb = new models_1.TimeCallback(`${this.roomName} Ambient Light after Sunset`, models_1.TimeCallbackType.SunSet, () => {
+                this.log(models_1.LogLevel.Info, `Draußen wird es dunkel --> Aktiviere Ambientenbeleuchtung`);
+                this.switchAll(true);
+                services_1.Utils.guardedTimeout(() => {
+                    this.log(models_1.LogLevel.Info, `Ambientenbeleuchtung um Mitternacht abschalten.`);
+                    this.switchAll(false);
+                }, services_1.Utils.timeTilMidnight, this);
+            }, this.getRoom().settings.lampOffset.sunset);
+            this.sonnenUntergangLichtCallback = cb;
+            services_1.TimeCallbackService.addCallback(cb);
+        }
+    }
 }
 exports.LampenGroup = LampenGroup;

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

@@ -33,14 +33,6 @@ class PraesenzGroup extends base_group_1.BaseGroup {
                 services_1.RoomService.movementHistory.add(`${services_1.Utils.nowString()}: Raum "${this.roomName}" Gerät "${b.info.fullName}"`);
             });
         });
-        if (this.getRoom().settings.lichtSonnenAufgangAus && this.getRoom().settings.lampOffset) {
-            const cb = new models_1.TimeCallback(`${this.roomName} Morgens Lampe aus`, models_1.TimeCallbackType.Sunrise, () => {
-                var _a;
-                (_a = this.getRoom().LampenGroup) === null || _a === void 0 ? void 0 : _a.handleSunriseOff();
-            }, this.getRoom().settings.lampOffset.sunrise);
-            this.getRoom().sonnenAufgangLichtCallback = cb;
-            services_1.TimeCallbackService.addCallback(cb);
-        }
         this.addLastLeftCallback(() => {
             var _a;
             (_a = this.getRoom().LampenGroup) === null || _a === void 0 ? void 0 : _a.switchAll(false);

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

@@ -1,15 +1,21 @@
+import { TimeCallback } from '../../../models';
 import { Window } from './Window';
 import { BaseGroup } from './base-group';
 export declare class WindowGroup extends BaseGroup {
     windows: Window[];
+    sunriseShutterCallback: TimeCallback | undefined;
+    sunsetShutterCallback: TimeCallback | undefined;
     constructor(roomName: string, windows: Window[]);
     allRolloDown(initial?: boolean, savePosition?: boolean): void;
     allRolloUp(savePosition?: boolean): void;
     allRolloToLevel(level: number, savePosition?: boolean): void;
     initialize(): void;
+    recalcTimeCallbacks(): void;
     setRolloByWeatherStatus(): void;
     sunriseUp(initial?: boolean): void;
     restoreRolloPosition(recalc?: boolean): void;
     changeVibrationMotionBlock(block: boolean): void;
     private sunsetDown;
+    private reconfigureSunsetShutterCallback;
+    private reconfigureSunriseShutterCallback;
 }

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

@@ -36,31 +36,7 @@ class WindowGroup extends base_group_1.BaseGroup {
     }
     initialize() {
         const room = this.getRoom();
-        if (room.settings.sonnenAufgangRollos && room.settings.rolloOffset) {
-            this.log(models_1.LogLevel.Trace, `Sonnenaufgang TimeCallback für ${this.roomName} hinzufügen`);
-            room.sonnenAufgangCallback = new models_1.TimeCallback(`${this.roomName} Sonnenaufgang Rollos`, models_1.TimeCallbackType.Sunrise, () => {
-                if (room.skipNextRolloUp) {
-                    room.skipNextRolloUp = false;
-                    return;
-                }
-                this.sunriseUp();
-            }, room.settings.rolloOffset.sunrise, undefined, undefined, room.settings.rolloOffset);
-            if (!services_1.TimeCallbackService.darkOutsideOrNight(services_1.TimeCallbackService.dayType(room.settings.rolloOffset))) {
-                this.sunriseUp(true);
-            }
-            services_1.TimeCallbackService.addCallback(room.sonnenAufgangCallback);
-        }
-        if (room.settings.sonnenUntergangRollos && room.settings.rolloOffset) {
-            room.sonnenUntergangCallback = new models_1.TimeCallback(`${this.roomName} Sonnenuntergang Rollo`, models_1.TimeCallbackType.SunSet, () => {
-                this.sunsetDown();
-            }, room.settings.rolloOffset.sunset);
-            if (services_1.TimeCallbackService.darkOutsideOrNight(services_1.TimeCallbackService.dayType(room.settings.rolloOffset))) {
-                services_1.Utils.guardedTimeout(() => {
-                    this.allRolloDown(true, true);
-                }, 60000, this);
-            }
-            services_1.TimeCallbackService.addCallback(room.sonnenUntergangCallback);
-        }
+        this.recalcTimeCallbacks();
         if (room.settings.rolloHeatReduction) {
             services_1.Utils.guardedInterval(this.setRolloByWeatherStatus, 15 * 60 * 1000, this, false);
             services_1.Utils.guardedTimeout(this.setRolloByWeatherStatus, 2 * 60 * 1000, this);
@@ -69,6 +45,10 @@ class WindowGroup extends base_group_1.BaseGroup {
             f.initialize();
         });
     }
+    recalcTimeCallbacks() {
+        this.reconfigureSunriseShutterCallback();
+        this.reconfigureSunsetShutterCallback();
+    }
     setRolloByWeatherStatus() {
         const room = this.getRoom();
         const timeOfDay = services_1.TimeCallbackService.dayType(room.settings.rolloOffset);
@@ -136,5 +116,66 @@ class WindowGroup extends base_group_1.BaseGroup {
             (_b = room.LampenGroup) === null || _b === void 0 ? void 0 : _b.switchTimeConditional(services_1.TimeCallbackService.dayType(room.settings.lampOffset));
         }
     }
+    reconfigureSunsetShutterCallback() {
+        const room = this.getRoom();
+        if (!room.settings.sonnenUntergangRollos || !room.settings.rolloOffset) {
+            if (this.sunsetShutterCallback !== undefined) {
+                this.log(models_1.LogLevel.Trace, `Remove Sunset Shutter callback for ${this.roomName}`);
+                services_1.TimeCallbackService.removeCallback(this.sunsetShutterCallback);
+                this.sunsetShutterCallback = undefined;
+            }
+            return;
+        }
+        if (this.sunsetShutterCallback && room.settings.rolloOffset) {
+            this.sunsetShutterCallback.minuteOffset = room.settings.rolloOffset.sunset;
+            this.sunsetShutterCallback.sunTimeOffset = room.settings.rolloOffset;
+            if (room.settings.sonnenUntergangRolloAdditionalOffsetPerCloudiness > 0) {
+                this.sunsetShutterCallback.cloudOffset =
+                    services_1.WeatherService.getCurrentCloudiness() * room.settings.sonnenUntergangRolloAdditionalOffsetPerCloudiness;
+            }
+            this.sunsetShutterCallback.recalcNextToDo(new Date());
+        }
+        if (this.sunsetShutterCallback === undefined) {
+            this.sunsetShutterCallback = new models_1.TimeCallback(`${this.roomName} Sunset Shutter`, models_1.TimeCallbackType.SunSet, () => {
+                this.sunsetDown();
+            }, room.settings.rolloOffset.sunset);
+            if (services_1.TimeCallbackService.darkOutsideOrNight(services_1.TimeCallbackService.dayType(room.settings.rolloOffset))) {
+                services_1.Utils.guardedTimeout(() => {
+                    this.allRolloDown(true, true);
+                }, 60000, this);
+            }
+            services_1.TimeCallbackService.addCallback(this.sunsetShutterCallback);
+        }
+    }
+    reconfigureSunriseShutterCallback() {
+        const room = this.getRoom();
+        if (!room.settings.sonnenAufgangRollos || !room.settings.rolloOffset) {
+            if (this.sunriseShutterCallback !== undefined) {
+                this.log(models_1.LogLevel.Trace, `Remove Sunrise Shutter callback for ${this.roomName}`);
+                services_1.TimeCallbackService.removeCallback(this.sunriseShutterCallback);
+                this.sunriseShutterCallback = undefined;
+            }
+            return;
+        }
+        if (this.sunriseShutterCallback && room.settings.rolloOffset) {
+            this.sunriseShutterCallback.minuteOffset = room.settings.rolloOffset.sunrise;
+            this.sunriseShutterCallback.sunTimeOffset = room.settings.rolloOffset;
+            this.sunriseShutterCallback.recalcNextToDo(new Date());
+        }
+        if (this.sunriseShutterCallback === undefined) {
+            this.log(models_1.LogLevel.Trace, `Add Sunrise shutter TimeCallback for ${this.roomName}`);
+            this.sunriseShutterCallback = new models_1.TimeCallback(`${this.roomName} Sonnenaufgang Rollos`, models_1.TimeCallbackType.Sunrise, () => {
+                if (room.skipNextRolloUp) {
+                    room.skipNextRolloUp = false;
+                    return;
+                }
+                this.sunriseUp();
+            }, room.settings.rolloOffset.sunrise, undefined, undefined, room.settings.rolloOffset);
+            if (!services_1.TimeCallbackService.darkOutsideOrNight(services_1.TimeCallbackService.dayType(room.settings.rolloOffset))) {
+                this.sunriseUp(true);
+            }
+            services_1.TimeCallbackService.addCallback(this.sunriseShutterCallback);
+        }
+    }
 }
 exports.WindowGroup = WindowGroup;

package/lib/server/services/ShutterService.js

@@ -30,8 +30,8 @@ class ShutterService {
             for (const f of r.WindowGroup.windows) {
                 f.getShutter().forEach((shutter) => {
                     var _a, _b, _c, _d;
-                    response.push(`Rollo: "${shutter.info.customName}"\t${f.noRolloOnSunrise ? 'Hochfahren inaktiv' : (_b = (_a = r.sonnenAufgangCallback) === null || _a === void 0 ? void 0 : _a.nextToDo) === null || _b === void 0 ? void 0 : _b.toLocaleTimeString()}`);
-                    down.push(`Rollo: "${shutter.info.customName}"\t${(_d = (_c = r.sonnenUntergangCallback) === null || _c === void 0 ? void 0 : _c.nextToDo) === null || _d === void 0 ? void 0 : _d.toLocaleTimeString()}`);
+                    response.push(`Rollo: "${shutter.info.customName}"\t${f.noRolloOnSunrise ? 'Hochfahren inaktiv' : (_b = (_a = r.sunriseShutterCallback) === null || _a === void 0 ? void 0 : _a.nextToDo) === null || _b === void 0 ? void 0 : _b.toLocaleTimeString()}`);
+                    down.push(`Rollo: "${shutter.info.customName}"\t${(_d = (_c = r.sunsetShutterCallback) === null || _c === void 0 ? void 0 : _c.nextToDo) === null || _d === void 0 ? void 0 : _d.toLocaleTimeString()}`);
                 });
             }
         }

package/lib/server/services/time-callback-service.js

@@ -117,12 +117,15 @@ class TimeCallbackService {
         this._iCheckTimeout = utils_1.Utils.guardedInterval(TimeCallbackService.performCheck.bind(this), 60000);
     }
     static addCallback(pCallback) {
-        TimeCallbackService._callbacks.push(pCallback);
+        if (TimeCallbackService._callbacks.has(pCallback.name)) {
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Overwriting existing TimeCallback "${pCallback.name}"`);
+        }
+        TimeCallbackService._callbacks.set(pCallback.name, pCallback);
     }
     static performCheck() {
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `Perform TimeCallBackCheck`);
         const now = new Date();
-        for (const tc of TimeCallbackService._callbacks) {
+        for (const tc of TimeCallbackService._callbacks.values()) {
             if (tc.nextToDo === undefined || tc.nextToDo < tc.lastDone) {
                 tc.recalcNextToDo(now);
             }
@@ -130,7 +133,7 @@ class TimeCallbackService {
                 continue;
             }
             if (tc.nextToDo < now && tc.nextToDo > TimeCallbackService._lastCheck) {
-                tc.cFunction();
+                tc.perform();
                 tc.lastDone = now;
                 tc.nextToDo = undefined;
             }
@@ -156,13 +159,11 @@ Next Sunrise: ${TimeCallbackService._nextSunRise.toLocaleString('de-DE')}
 Next Sunset: ${TimeCallbackService._nextSunSet.toLocaleString('de-DE')}`);
     }
     static removeCallback(pCallback) {
-        for (let i = 0; i < TimeCallbackService._callbacks.length; i++) {
-            const cb = TimeCallbackService._callbacks[i];
-            if (cb.name !== pCallback.name) {
-                continue;
-            }
-            TimeCallbackService._callbacks.splice(i, 1);
-            return;
+        if (TimeCallbackService._callbacks.has(pCallback.name)) {
+            TimeCallbackService._callbacks.delete(pCallback.name);
+        }
+        else {
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `TimeCallback to remove ("${pCallback.name}") doesn't exist.`);
         }
     }
     static updateSunRise(pDay = new Date(), lat, long) {
@@ -176,5 +177,5 @@ Next Sunset: ${TimeCallbackService._nextSunSet.toLocaleString('de-DE')}`);
     }
 }
 exports.TimeCallbackService = TimeCallbackService;
-TimeCallbackService._callbacks = [];
+TimeCallbackService._callbacks = new Map();
 TimeCallbackService._lastCheck = new Date(0);