hoffmation-base 0.1.41-1 → 0.1.41-13

package/lib/server/services/calendar/m/303/274ll-service.js

@@ -2,30 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MuellService = void 0;
 const node_ical_1 = require("node-ical");
-const timeCallback_1 = require("../../../models/timeCallback");
-const log_service_1 = require("../log-service/log-service");
-const utils_1 = require("../utils/utils");
+const models_1 = require("../../../models");
+const log_service_1 = require("../log-service");
+const utils_1 = require("../utils");
 const muell_tonne_1 = require("./muell-tonne");
 const time_callback_service_1 = require("../time-callback-service");
-const logLevel_1 = require("../../../models/logLevel");
 class MuellService {
     static intialize(config, defaultSonosDevice) {
         this.defaultSonosDevice = defaultSonosDevice;
         this._active = true;
         this._calendarURL = config.calendarURL;
-        this.updateTimeCallback = new timeCallback_1.TimeCallback('MuelltonnenServiceUpdater', timeCallback_1.TimeCallbackType.TimeOfDay, () => {
+        this.updateTimeCallback = new models_1.TimeCallback('MuelltonnenServiceUpdater', models_1.TimeCallbackType.TimeOfDay, () => {
             this.updateCalendar(false);
         }, 0, 2, 0);
         time_callback_service_1.TimeCallbackService.addCallback(this.updateTimeCallback);
-        this.checkTimeCallback = new timeCallback_1.TimeCallback('MuelltonnenServiceChecker', timeCallback_1.TimeCallbackType.TimeOfDay, () => {
+        this.checkTimeCallback = new models_1.TimeCallback('MuelltonnenServiceChecker', models_1.TimeCallbackType.TimeOfDay, () => {
             this.checkAll();
         }, 0, 18, 0);
         time_callback_service_1.TimeCallbackService.addCallback(this.checkTimeCallback);
         this.updateCalendar();
     }
     static updateCalendar(checkAfterwards = true) {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Muell Service wird nun initialisiert`);
-        node_ical_1.async.fromURL(this._calendarURL).then((data) => {
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Muell Service wird nun initialisiert`);
+        node_ical_1.async
+            .fromURL(this._calendarURL)
+            .then((data) => {
             this.gelbeTonne = new muell_tonne_1.MuellTonne('Gelbe Tonne', this.defaultSonosDevice);
             this.graueTonne = new muell_tonne_1.MuellTonne('Graue Tonne', this.defaultSonosDevice);
             this.blaueTonne = new muell_tonne_1.MuellTonne('Blaue Tonne', this.defaultSonosDevice);
@@ -40,7 +41,7 @@ class MuellService {
                     continue;
                 }
                 const ev = data[k];
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `${ev.summary} is in ${ev.location} on the ${ev.start.getDate()} of ${this.months[ev.start.getMonth()]} at ${ev.start.toLocaleTimeString('en-GB')}`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.DeepTrace, `${ev.summary} is in ${ev.location} on the ${ev.start.getDate()} of ${this.months[ev.start.getMonth()]} at ${ev.start.toLocaleTimeString('en-GB')}`);
                 if (ev.start.getTime() < todayMidnight) {
                     continue;
                 }
@@ -59,7 +60,7 @@ class MuellService {
                         this.brauneTonne.dates.push(ev.start);
                         break;
                     default:
-                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Unbekannte Mülltonne (${ev.summary})`);
+                        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Unbekannte Mülltonne (${ev.summary})`);
                 }
             }
             this.gelbeTonne.sortDates();
@@ -70,6 +71,9 @@ class MuellService {
             if (checkAfterwards) {
                 this.checkAll();
             }
+        })
+            .catch((r) => {
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Loading Trash Calendar failed with error: "${r}"`);
         });
     }
     static checkAll(pRetries = 10) {
@@ -78,18 +82,18 @@ class MuellService {
         }
         const now = new Date();
         if (now.getTime() - this.lastCheck.getTime() < 60000 && now.getDate() === this.lastCheck.getDate()) {
-            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `MüllService.checkAll: Skipped weil wir gerade erst geprüft hatten.`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `MüllService.checkAll: Skipped weil wir gerade erst geprüft hatten.`);
             return;
         }
         if (this.gelbeTonne === undefined) {
             if (pRetries > 0) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Der Müllservice ist noch nicht bereit --> warten`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Der Müllservice ist noch nicht bereit --> warten`);
                 utils_1.Utils.guardedTimeout(() => {
                     MuellService.checkAll(pRetries - 1);
                 }, 1000);
             }
             else {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Der Müllservice ist trotz Warten nicht bereit --> Abbruch`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Der Müllservice ist trotz Warten nicht bereit --> Abbruch`);
             }
             return;
         }
@@ -102,7 +106,7 @@ class MuellService {
 }
 exports.MuellService = MuellService;
 MuellService.alleTonnen = [];
+MuellService.months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 MuellService.lastCheck = new Date(0);
 MuellService._active = false;
 MuellService.defaultSonosDevice = undefined;
-MuellService.months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];

package/lib/server/services/dbo/postgreSqlPersist.d.ts

@@ -1,13 +1,13 @@
 import { iPersist } from './iPersist';
-import { RoomBase } from '../../../models/rooms/RoomBase';
-import { IoBrokerBaseDevice } from '../../devices/IoBrokerBaseDevice';
-import { CountToday } from '../../../models/persistence/todaysCount';
-import { TemperaturDataPoint } from '../../../models/persistence/temperaturDataPoint';
-import { HmIpHeizgruppe } from '../../devices/hmIPDevices/hmIpHeizgruppe';
-import { CurrentIlluminationDataPoint } from '../../../models/persistence/CurrentIlluminationDataPoint';
-import { iPersistenceSettings } from '../../config/iConfig';
-import { ShutterCalibration } from '../../../models/persistence/ShutterCalibration';
-import { EnergyCalculation } from '../../../models/persistence/EnergyCalculation';
+import { RoomBase } from '../../../models';
+import { IoBrokerBaseDevice } from '../../devices';
+import { CountToday } from '../../../models';
+import { TemperaturDataPoint } from '../../../models';
+import { HmIpHeizgruppe } from '../../devices';
+import { CurrentIlluminationDataPoint } from '../../../models';
+import { iPersistenceSettings } from '../../config';
+import { ShutterCalibration } from '../../../models';
+import { EnergyCalculation } from '../../../models';
 export declare class PostgreSqlPersist implements iPersist {
     private psql;
     initialized: boolean;

package/lib/server/services/dbo/postgreSqlPersist.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgreSqlPersist = void 0;
-const todaysCount_1 = require("../../../models/persistence/todaysCount");
+const models_1 = require("../../../models");
 const pg_1 = require("pg");
-const log_service_1 = require("../log-service/log-service");
-const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../log-service");
+const models_2 = require("../../../models");
 class PostgreSqlPersist {
     constructor(config) {
         this.initialized = false;
@@ -22,7 +22,7 @@ values ('${room.roomName}',${room.settings.etage})
     `);
     }
     addTemperaturDataPoint(hzGrp) {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Persisting Temperatur Data for ${hzGrp.info.customName}`);
+        log_service_1.ServerLogService.writeLog(models_2.LogLevel.Trace, `Persisting Temperatur Data for ${hzGrp.info.customName}`);
         this.query(`
 insert into hoffmation_schema."TemperaturData" ("date", humidity, "istTemperatur", level, name, "sollTemperatur")
 values ('${new Date().toISOString()}',${hzGrp.humidity},${hzGrp.iTemperatur},${hzGrp.iLevel},'${hzGrp.info.customName}',${hzGrp.desiredTemperatur});`);
@@ -44,11 +44,11 @@ values ('${new Date().toISOString()}',${hzGrp.humidity},${hzGrp.iTemperatur},${h
         if (dbResult !== null && dbResult.length > 0) {
             return dbResult[0];
         }
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Es gibt noch keinen persistierten Counter für ${device.info.fullName}`);
-        return new todaysCount_1.CountToday(device.info.fullID, 0);
+        log_service_1.ServerLogService.writeLog(models_2.LogLevel.Debug, `Es gibt noch keinen persistierten Counter für ${device.info.fullName}`);
+        return new models_1.CountToday(device.info.fullID, 0);
     }
     getShutterCalibration(_device) {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Postgres doesn't support Shutter Calibration yet.`);
+        log_service_1.ServerLogService.writeLog(models_2.LogLevel.Warn, `Postgres doesn't support Shutter Calibration yet.`);
         return new Promise((_res, reject) => {
             reject('Not Implemented');
         });
@@ -182,7 +182,7 @@ alter table "TemperaturData"
 END
 $$;`);
         this.initialized = true;
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Postgres DB initialized`);
+        log_service_1.ServerLogService.writeLog(models_2.LogLevel.Info, `Postgres DB initialized`);
     }
     persistCurrentIllumination(data) {
         this.query(`
@@ -191,7 +191,7 @@ values ('${data.roomName}','${data.deviceID}',${data.currentIllumination},'${dat
     `);
     }
     persistShutterCalibration(_data) {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Postgres doesn't support Shutter Calibration yet.`);
+        log_service_1.ServerLogService.writeLog(models_2.LogLevel.Warn, `Postgres doesn't support Shutter Calibration yet.`);
     }
     persistTodayCount(device, count, oldCount) {
         this.query(`
@@ -238,18 +238,18 @@ LIMIT ${limit}
                 resolve(result.rows);
             })
                 .catch((r) => {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Postgres Query failed: ${r}`);
+                log_service_1.ServerLogService.writeLog(models_2.LogLevel.Warn, `Postgres Query failed: ${r}`);
                 resolve(null);
             });
         });
     }
     isPsqlReady() {
         if (!this.initialized) {
-            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Db is not yet initialized`);
+            log_service_1.ServerLogService.writeLog(models_2.LogLevel.Warn, `Db is not yet initialized`);
             return false;
         }
         if (!this.psql) {
-            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `PSQL client missing`);
+            log_service_1.ServerLogService.writeLog(models_2.LogLevel.Error, `PSQL client missing`);
             return false;
         }
         return true;
@@ -258,7 +258,7 @@ LIMIT ${limit}
         this.query(`
 insert into hoffmation_schema."EnergyCalculation" ("startDate", "endDate", "selfConsumedKwH", "injectedKwH",
                                                    "drawnKwH")
-values ('${new Date(calc.startMs).toISOString()}','${new Date(calc.startMs).toISOString()}',
+values ('${new Date(calc.startMs).toISOString()}','${new Date(calc.endMs).toISOString()}',
         ${calc.selfConsumedKwH}, ${calc.injectedKwH}, ${calc.drawnKwH});
     `);
     }

package/lib/server/services/room-service/room-service.d.ts

@@ -1,7 +1,6 @@
-import { ringStorage } from '../utils/ringstorage';
-import { RoomBase } from '../../../models/rooms/RoomBase';
-import { iRoomBase } from '../../../models/rooms/iRoomBase';
-import { IoBrokerBaseDevice } from '../../devices/IoBrokerBaseDevice';
+import { ringStorage } from '../utils';
+import { iRoomBase, RoomBase } from '../../../models';
+import { IBaseDevice } from '../../devices';
 export declare class RoomService {
     static Rooms: Map<string, RoomBase>;
     static awayModeActive: boolean;
@@ -27,11 +26,11 @@ export declare class RoomService {
      * @param floor the level on which all lamps shall be changed -1 equals all rooms
      * @param status
      */
-    static setAllLampsOfFloor(floor: number, status?: boolean): void;
+    static setAllLampsOfFloor(floor: number, status?: boolean, timeout?: number): void;
     static clearAllAlarms(): void;
     static startAwayMode(): void;
     static startNightAlarmMode(): void;
-    static startIntrusionAlarm(room: iRoomBase, device: IoBrokerBaseDevice): void;
+    static startIntrusionAlarm(room: iRoomBase, device: IBaseDevice): void;
     static endAlarmModes(): void;
     static getLastMovements(): string;
     private static stopIntrusionAlarm;

package/lib/server/services/room-service/room-service.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoomService = void 0;
-const ringstorage_1 = require("../utils/ringstorage");
-const log_service_1 = require("../log-service/log-service");
-const logLevel_1 = require("../../../models/logLevel");
-const sonos_service_1 = require("../Sonos/sonos-service");
-const res_1 = require("../Translation/res");
-const utils_1 = require("../utils/utils");
-const telegram_service_1 = require("../Telegram/telegram-service");
+const utils_1 = require("../utils");
+const models_1 = require("../../../models");
+const log_service_1 = require("../log-service");
+const Sonos_1 = require("../Sonos");
+const Translation_1 = require("../Translation");
+const Telegram_1 = require("../Telegram");
 class RoomService {
     static addToRoomList(room) {
         RoomService.Rooms.set(room.roomName, room);
@@ -34,12 +33,12 @@ class RoomService {
      * @param floor the level on which all lamps shall be changed -1 equals all rooms
      * @param status
      */
-    static setAllLampsOfFloor(floor, status = false) {
+    static setAllLampsOfFloor(floor, status = false, timeout) {
         var _a, _b, _c;
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Schalte alle Lampen in Etage ${floor} auf den Wert ${status}`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Schalte alle Lampen in Etage ${floor} auf den Wert ${status}`);
         const rooms = floor > -1 ? this.getAllRoomsOfFloor(floor) : this.Rooms.entries();
         for (const [_name, room] of rooms) {
-            (_a = room.LampenGroup) === null || _a === void 0 ? void 0 : _a.setAllLampen(status, -1, true);
+            (_a = room.LampenGroup) === null || _a === void 0 ? void 0 : _a.setAllLampen(status, -1, true, timeout);
             (_b = room.LampenGroup) === null || _b === void 0 ? void 0 : _b.setAllLED(status);
             (_c = room.LampenGroup) === null || _c === void 0 ? void 0 : _c.setAllStecker(status, -1, true);
         }
@@ -58,36 +57,36 @@ class RoomService {
         this.restoreLight();
     }
     static startAwayMode() {
-        sonos_service_1.SonosService.speakOnAll(res_1.Res.alarmArmed(), 40);
+        Sonos_1.SonosService.speakOnAll(Translation_1.Res.alarmArmed(), 40);
         if (this._awayModeTimeout) {
             clearTimeout(this._awayModeTimeout);
         }
         this._awayModeTimeout = utils_1.Utils.guardedTimeout(() => {
             this.awayModeActive = true;
             this._awayModeTimeout = undefined;
-            telegram_service_1.TelegramService.inform(`Alarm ist nun scharf. Gute Reise!`);
+            Telegram_1.TelegramService.inform(`Alarm ist nun scharf. Gute Reise!`);
         }, 60000, this);
     }
     static startNightAlarmMode() {
-        sonos_service_1.SonosService.speakOnAll(res_1.Res.alarmNightModeArmed(), 30);
+        Sonos_1.SonosService.speakOnAll(Translation_1.Res.alarmNightModeArmed(), 30);
         if (this._nightModeTimeout) {
             clearTimeout(this._nightModeTimeout);
         }
         this._nightModeTimeout = utils_1.Utils.guardedTimeout(() => {
             this.nightAlarmActive = true;
             this._nightModeTimeout = undefined;
-            telegram_service_1.TelegramService.inform(`Alarm ist nun scharf. Süße Träume!`);
+            Telegram_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);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, message);
         if (!this.awayModeActive && !this.nightAlarmActive) {
             this.stopIntrusionAlarm();
             return;
         }
         utils_1.Utils.guardedNewThread(() => {
-            telegram_service_1.TelegramService.inform(message);
+            Telegram_1.TelegramService.inform(message);
         }, this);
         if (this._intrusionAlarmActive) {
             return;
@@ -97,12 +96,12 @@ class RoomService {
     }
     static endAlarmModes() {
         if (this.awayModeActive) {
-            telegram_service_1.TelegramService.sendMessage(telegram_service_1.TelegramService.subscribedIDs, `Alarmanalage entschärft`);
-            sonos_service_1.SonosService.speakOnAll(res_1.Res.welcomeHome(), 35);
+            Telegram_1.TelegramService.sendMessage(Telegram_1.TelegramService.subscribedIDs, `Alarmanalage entschärft`);
+            Sonos_1.SonosService.speakOnAll(Translation_1.Res.welcomeHome(), 35);
         }
         if (this.nightAlarmActive) {
-            telegram_service_1.TelegramService.sendMessage(telegram_service_1.TelegramService.subscribedIDs, `Nachtmodus der Alarmanlage entschärft`);
-            sonos_service_1.SonosService.speakOnAll(res_1.Res.goodMorning(), 30);
+            Telegram_1.TelegramService.sendMessage(Telegram_1.TelegramService.subscribedIDs, `Nachtmodus der Alarmanlage entschärft`);
+            Sonos_1.SonosService.speakOnAll(Translation_1.Res.goodMorning(), 30);
         }
         if (this._nightModeTimeout) {
             clearTimeout(this._nightModeTimeout);
@@ -118,7 +117,7 @@ class RoomService {
         return this.movementHistory.readAmount(15).join('\n');
     }
     static stopIntrusionAlarm() {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Stoppe Intrusion Alarm`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Stoppe Intrusion Alarm`);
         if (this._intrusionAlarmTimeout) {
             clearTimeout(this._intrusionAlarmTimeout);
         }
@@ -127,7 +126,7 @@ class RoomService {
         }
         this._intrusionAlarmActive = false;
         this._intrusionAlarmLevel = 0;
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Alarm wurde beendet --> Fahre Rollos in Ausgangsposition.`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Alert, `Alarm wurde beendet --> Fahre Rollos in Ausgangsposition.`);
         this.restoreRolloPosition();
         this.restoreLight();
     }
@@ -142,11 +141,11 @@ class RoomService {
         let newTimeout = 20000;
         const alarmAutomaticEnd = 15;
         if (this._intrusionAlarmLevel === 1) {
-            speakMessage = res_1.Res.intruderGreeting();
+            speakMessage = Translation_1.Res.intruderGreeting();
             volume = 40;
         }
         else if (this._intrusionAlarmLevel === 2) {
-            speakMessage = res_1.Res.intruderShutterUpPleaseLeave();
+            speakMessage = Translation_1.Res.intruderShutterUpPleaseLeave();
             utils_1.Utils.guardedNewThread(() => {
                 this.setAllRolloOfFloor(-1, 100);
                 this.setAllLampsOfFloor(-1, true);
@@ -154,11 +153,11 @@ class RoomService {
         }
         else if (this._intrusionAlarmLevel === 3) {
             volume = 70;
-            speakMessage = res_1.Res.intruderLeaveAndOwnerInformed();
+            speakMessage = Translation_1.Res.intruderLeaveAndOwnerInformed();
         }
         else if (this._intrusionAlarmLevel <= 5) {
             volume = 80;
-            speakMessage = res_1.Res.intruderAdditionalDefenseWarning();
+            speakMessage = Translation_1.Res.intruderAdditionalDefenseWarning();
         }
         else if (this._intrusionAlarmLevel >= alarmAutomaticEnd) {
             this.stopIntrusionAlarm();
@@ -166,15 +165,15 @@ class RoomService {
         }
         else {
             volume = 90;
-            speakMessage = res_1.Res.intruderAlarm();
+            speakMessage = Translation_1.Res.intruderAlarm();
             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}`);
+            Sonos_1.SonosService.speakOnAll(speakMessage, volume);
+            Telegram_1.TelegramService.inform(`Eindringling erhielt folgende Nachricht: "${speakMessage}"\nAlarmlevel ist ${this._intrusionAlarmLevel}\t Automatisches Ende bei ${alarmAutomaticEnd}`);
         }, this);
     }
     static restoreRolloPosition() {
@@ -193,6 +192,6 @@ exports.RoomService = RoomService;
 RoomService.Rooms = new Map();
 RoomService.awayModeActive = false;
 RoomService.nightAlarmActive = false;
-RoomService.movementHistory = new ringstorage_1.ringStorage(15);
+RoomService.movementHistory = new utils_1.ringStorage(15);
 RoomService._intrusionAlarmActive = false;
 RoomService._intrusionAlarmLevel = 0;

package/lib/server/services/time-callback-service.d.ts

@@ -1,10 +1,4 @@
-import { TimeCallback } from '../../models/timeCallback';
-export declare enum TimeOfDay {
-    BeforeSunrise = 1,
-    Daylight = 2,
-    AfterSunset = 3,
-    Night = 4
-}
+import { TimeCallback, TimeOfDay } from '../../models';
 export declare class SunTimeOffsets {
     sunrise: number;
     sunset: number;
@@ -13,27 +7,27 @@ export declare class SunTimeOffsets {
     maximumHours: number;
     maximumMinutes: number;
     constructor(sunrise?: number, sunset?: number, minimumHours?: number, minimumMinutes?: number, maximumHours?: number, maximumMinutes?: number);
-    getNextMinimumSunrise(): Date;
-    getNextMaximumSunset(): Date;
+    getNextMinimumSunrise(date?: Date): Date;
+    getNextMaximumSunset(date?: Date): Date;
 }
 export declare class TimeCallbackService {
     private static _todaySunRise;
     private static _todaySunSet;
-    private static _nextSunRise;
-    private static _nextSunSet;
     private static _callbacks;
     private static _iCheckTimeout;
     private static _lastCheck;
+    private static _nextSunRise;
+    static get nextSunRise(): Date;
+    private static _nextSunSet;
+    static get nextSunSet(): Date;
     static dayType(pOffset: SunTimeOffsets): TimeOfDay;
     static darkOutsideOrNight(dayType: TimeOfDay): boolean;
     static stopInterval(): void;
-    static get nextSunRise(): Date;
-    static get nextSunSet(): Date;
     static init(): void;
     static addCallback(pCallback: TimeCallback): void;
     static performCheck(): void;
     static recalcSunTimes(): void;
     static removeCallback(pCallback: TimeCallback): void;
-    static updateSunRise(pDay?: Date): void;
-    static updateSunSet(pDay?: Date): void;
+    static updateSunRise(pDay?: Date, lat?: number, long?: number): void;
+    static updateSunSet(pDay?: Date, lat?: number, long?: number): void;
 }

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

@@ -1,20 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeCallbackService = exports.SunTimeOffsets = exports.TimeOfDay = void 0;
+exports.TimeCallbackService = exports.SunTimeOffsets = void 0;
 const sunrise_sunset_js_1 = require("sunrise-sunset-js");
-const timeCallback_1 = require("../../models/timeCallback");
-const log_service_1 = require("./log-service/log-service");
-const utils_1 = require("./utils/utils");
+const models_1 = require("../../models");
+const log_service_1 = require("./log-service");
+const utils_1 = require("./utils");
 const settings_service_1 = require("./settings-service");
-const devices_1 = require("../devices/devices");
-const logLevel_1 = require("../../models/logLevel");
-var TimeOfDay;
-(function (TimeOfDay) {
-    TimeOfDay[TimeOfDay["BeforeSunrise"] = 1] = "BeforeSunrise";
-    TimeOfDay[TimeOfDay["Daylight"] = 2] = "Daylight";
-    TimeOfDay[TimeOfDay["AfterSunset"] = 3] = "AfterSunset";
-    TimeOfDay[TimeOfDay["Night"] = 4] = "Night";
-})(TimeOfDay = exports.TimeOfDay || (exports.TimeOfDay = {}));
+const devices_1 = require("../devices");
 class SunTimeOffsets {
     constructor(sunrise = 0, sunset = 0, minimumHours = 6, minimumMinutes = 24, maximumHours = 22, maximumMinutes = 30) {
         this.sunrise = sunrise;
@@ -24,23 +16,31 @@ class SunTimeOffsets {
         this.maximumHours = maximumHours;
         this.maximumMinutes = maximumMinutes;
     }
-    getNextMinimumSunrise() {
-        const today = new Date(new Date().setHours(this.minimumHours, this.minimumMinutes));
-        if (today > new Date()) {
+    getNextMinimumSunrise(date = new Date()) {
+        const dateCopy = new Date(date);
+        const today = new Date(dateCopy.setHours(this.minimumHours, this.minimumMinutes, 0, 0));
+        if (today > date) {
             return today;
         }
-        return new Date(today.getTime() + 24 * 60 * 60 * 1000);
+        return new Date(today.setDate(today.getDate() + 1));
     }
-    getNextMaximumSunset() {
-        const today = new Date(new Date().setHours(this.maximumHours, this.maximumMinutes));
-        if (today > new Date()) {
+    getNextMaximumSunset(date = new Date()) {
+        const dateCopy = new Date(date);
+        const today = new Date(dateCopy.setHours(this.maximumHours, this.maximumMinutes, 0, 0));
+        if (today > date) {
             return today;
         }
-        return new Date(today.getTime() + 24 * 60 * 60 * 1000);
+        return new Date(today.setDate(today.getDate() + 1));
     }
 }
 exports.SunTimeOffsets = SunTimeOffsets;
 class TimeCallbackService {
+    static get nextSunRise() {
+        return TimeCallbackService._nextSunRise;
+    }
+    static get nextSunSet() {
+        return TimeCallbackService._nextSunSet;
+    }
     static dayType(pOffset) {
         const now = new Date();
         const hours = now.getHours();
@@ -51,7 +51,7 @@ class TimeCallbackService {
             if ((hours < nightEnd.hours && hours > nightStart.hours) ||
                 (hours === nightEnd.hours && minutes < nightEnd.minutes) ||
                 (hours === nightStart.hours && minutes > nightStart.minutes)) {
-                return TimeOfDay.Night;
+                return models_1.TimeOfDay.Night;
             }
         }
         else {
@@ -59,7 +59,7 @@ class TimeCallbackService {
                 hours < nightEnd.hours ||
                 (hours === nightStart.hours && minutes >= nightStart.minutes) ||
                 (hours === nightEnd.hours && minutes <= nightEnd.minutes)) {
-                return TimeOfDay.Night;
+                return models_1.TimeOfDay.Night;
             }
         }
         let sunset = new Date(TimeCallbackService._todaySunSet.getTime() + pOffset.sunset * 60 * 1000);
@@ -68,11 +68,11 @@ class TimeCallbackService {
             maximumSunset.setDate(maximumSunset.getDate() - 1);
         }
         if (maximumSunset < sunset && maximumSunset.getDate() === sunset.getDate()) {
-            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Maximum Sunset vor nächstem Sunset: Sunset ${sunset.toLocaleString()}\t\t${maximumSunset.toLocaleString()}`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `Maximum Sunset vor nächstem Sunset: Sunset ${sunset.toLocaleString()}\t\t${maximumSunset.toLocaleString()}`);
             sunset = maximumSunset;
         }
         if (now > sunset) {
-            return TimeOfDay.AfterSunset;
+            return models_1.TimeOfDay.AfterSunset;
         }
         const minimumSunrise = pOffset.getNextMinimumSunrise();
         let sunrise = new Date(TimeCallbackService._todaySunRise.getTime() + pOffset.sunrise * 60 * 1000);
@@ -80,19 +80,19 @@ class TimeCallbackService {
             minimumSunrise.setDate(minimumSunrise.getDate() - 1);
         }
         if (minimumSunrise > sunrise && minimumSunrise.getDate() === sunrise.getDate()) {
-            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Minimum Sunset nach aktuellem Sunrise: Sunset ${sunrise.toLocaleString()}\t\t${minimumSunrise.toLocaleString()}`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `Minimum Sunset nach aktuellem Sunrise: Sunset ${sunrise.toLocaleString()}\t\t${minimumSunrise.toLocaleString()}`);
             sunrise = minimumSunrise;
         }
         if (now < sunrise && now.getDate() == sunrise.getDate()) {
-            return TimeOfDay.BeforeSunrise;
+            return models_1.TimeOfDay.BeforeSunrise;
         }
-        return TimeOfDay.Daylight;
+        return models_1.TimeOfDay.Daylight;
     }
     static darkOutsideOrNight(dayType) {
         switch (dayType) {
-            case TimeOfDay.Night:
-            case TimeOfDay.BeforeSunrise:
-            case TimeOfDay.AfterSunset:
+            case models_1.TimeOfDay.Night:
+            case models_1.TimeOfDay.BeforeSunrise:
+            case models_1.TimeOfDay.AfterSunset:
                 return true;
             default:
                 return false;
@@ -104,18 +104,12 @@ class TimeCallbackService {
             this._iCheckTimeout = undefined;
         }
     }
-    static get nextSunRise() {
-        return TimeCallbackService._nextSunRise;
-    }
-    static get nextSunSet() {
-        return TimeCallbackService._nextSunSet;
-    }
     static init() {
-        const dailyRecalc = new timeCallback_1.TimeCallback('Midnight Recalc', timeCallback_1.TimeCallbackType.TimeOfDay, () => {
+        const dailyRecalc = new models_1.TimeCallback('Midnight Recalc', models_1.TimeCallbackType.TimeOfDay, () => {
             TimeCallbackService.recalcSunTimes();
             devices_1.Devices.midnightReset();
         }, 0, 0, 0);
-        const daily3oClockRecalc = new timeCallback_1.TimeCallback('Daily3oClockRecalc', timeCallback_1.TimeCallbackType.TimeOfDay, () => {
+        const daily3oClockRecalc = new models_1.TimeCallback('Daily3oClockRecalc', models_1.TimeCallbackType.TimeOfDay, () => {
             devices_1.Devices.resetPraesenzCount();
         }, 0, 3, 0);
         TimeCallbackService.recalcSunTimes();
@@ -127,7 +121,7 @@ class TimeCallbackService {
         TimeCallbackService._callbacks.push(pCallback);
     }
     static performCheck() {
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Perform TimeCallBackCheck`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `Perform TimeCallBackCheck`);
         const now = new Date();
         for (const tc of TimeCallbackService._callbacks) {
             if (tc.nextToDo === undefined || tc.nextToDo < tc.lastDone) {
@@ -157,7 +151,7 @@ class TimeCallbackService {
         TimeCallbackService._todaySunSet = (0, sunrise_sunset_js_1.getSunset)(51.529556852253826, 7.097266042276687, new Date());
         TimeCallbackService.updateSunSet();
         TimeCallbackService.updateSunRise();
-        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Nächster Sonnenaufgang um ${TimeCallbackService.nextSunRise.toLocaleTimeString('de-DE')}
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Nächster Sonnenaufgang um ${TimeCallbackService.nextSunRise.toLocaleTimeString('de-DE')}
 Nächster Sonnenuntergang um ${TimeCallbackService._nextSunSet.toLocaleTimeString('de-DE')}`);
     }
     static removeCallback(pCallback) {
@@ -170,11 +164,11 @@ Nächster Sonnenuntergang um ${TimeCallbackService._nextSunSet.toLocaleTimeStrin
             return;
         }
     }
-    static updateSunRise(pDay = new Date()) {
-        TimeCallbackService._nextSunRise = (0, sunrise_sunset_js_1.getSunrise)(51.529556852253826, 7.097266042276687, pDay);
+    static updateSunRise(pDay = new Date(), lat = 51.529556852253826, long = 7.097266042276687) {
+        TimeCallbackService._nextSunRise = (0, sunrise_sunset_js_1.getSunrise)(lat, long, pDay);
     }
-    static updateSunSet(pDay = new Date()) {
-        TimeCallbackService._nextSunSet = (0, sunrise_sunset_js_1.getSunset)(51.529556852253826, 7.097266042276687, pDay);
+    static updateSunSet(pDay = new Date(), lat = 51.529556852253826, long = 7.097266042276687) {
+        TimeCallbackService._nextSunSet = (0, sunrise_sunset_js_1.getSunset)(lat, long, pDay);
     }
 }
 exports.TimeCallbackService = TimeCallbackService;

package/lib/server/services/utils/utils.d.ts

@@ -1,5 +1,7 @@
 /// <reference types="node" />
+import { iPersist } from '../dbo';
 export declare class Utils {
+    static dbo: iPersist | undefined;
     static catchEm<T>(promise: Promise<T>): Promise<{
         reason: Error | null;
         data: T | null;