hoffmation-base 0.1.14 → 0.1.18

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MuellService = void 0;
+const node_ical_1 = require("node-ical");
+const log_service_1 = require("../log-service");
+const time_callback_service_1 = require("../time-callback-service");
+const logLevel_1 = require("../../../models/logLevel");
+const timeCallback_1 = require("../../../models/timeCallback");
+const utils_1 = require("../utils/utils");
+const muell_tonne_1 = require("./muell-tonne");
+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.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.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) => {
+            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);
+            this.brauneTonne = new muell_tonne_1.MuellTonne('Braune Tonne', this.defaultSonosDevice);
+            this.alleTonnen = [];
+            const todayMidnight = new Date().setHours(0, 0, 0, 0);
+            for (const k in data) {
+                if (!data.hasOwnProperty(k)) {
+                    continue;
+                }
+                if (data[k].type !== 'VEVENT') {
+                    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')}`);
+                if (ev.start.getTime() < todayMidnight) {
+                    continue;
+                }
+                this.alleTonnen.push({ name: ev.summary, date: ev.start });
+                switch (ev.summary) {
+                    case this.gelbeTonne.name:
+                        this.gelbeTonne.dates.push(ev.start);
+                        break;
+                    case this.graueTonne.name:
+                        this.graueTonne.dates.push(ev.start);
+                        break;
+                    case this.blaueTonne.name:
+                        this.blaueTonne.dates.push(ev.start);
+                        break;
+                    case this.brauneTonne.name:
+                        this.brauneTonne.dates.push(ev.start);
+                        break;
+                    default:
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Unbekannte Mülltonne (${ev.summary})`);
+                }
+            }
+            this.gelbeTonne.sortDates();
+            this.graueTonne.sortDates();
+            this.blaueTonne.sortDates();
+            this.brauneTonne.sortDates();
+            this.alleTonnen = this.alleTonnen.sort((a, b) => a.date.getTime() - b.date.getTime());
+            if (checkAfterwards) {
+                this.checkAll();
+            }
+        });
+    }
+    static checkAll(pRetries = 10) {
+        if (!this._active) {
+            return;
+        }
+        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.`);
+            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`);
+                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`);
+            }
+            return;
+        }
+        this.lastCheck = now;
+        this.gelbeTonne.check();
+        this.graueTonne.check();
+        this.blaueTonne.check();
+        this.brauneTonne.check();
+    }
+}
+exports.MuellService = MuellService;
+MuellService.alleTonnen = [];
+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/index.d.ts

@@ -0,0 +1 @@
+export * from './persist';

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

@@ -0,0 +1,13 @@
+"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("./persist"), exports);

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

@@ -0,0 +1,27 @@
+import { TemperaturDataPoint } from '../../../models/persistence/temperaturDataPoint';
+import { CountToday } from '../../../models/persistence/todaysCount';
+import { HmIpHeizgruppe } from '../../devices/hmIPDevices/hmIpHeizgruppe';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { CurrentIlluminationDataPoint } from '../../../models/persistence/CurrentIlluminationDataPoint';
+import { ioBrokerBaseDevice } from '../../devices/iIoBrokerDevice';
+import { Mongo } from 'meteor/mongo';
+export declare class Persist {
+    private static TemperatureHistoryCollection;
+    private static HeatGroupCollection;
+    private static BasicRoomCollection;
+    private static RoomDetailsCollection;
+    private static CountTodayCollection;
+    private static CurrentIlluminationCollection;
+    private static DailyMovementCountTodayCollection;
+    static MeteorBound: (callback: any) => void;
+    private static Mongo;
+    static addTemperaturDataPoint(hzGrp: HmIpHeizgruppe): void;
+    static addRoom(room: RoomBase): void;
+    static getCount(device: ioBrokerBaseDevice): Promise<CountToday>;
+    static initialize(meteorBound: (callback: any) => void, mongo: {
+        Collection: Mongo.CollectionStatic;
+    }): void;
+    static persistTodayCount(device: ioBrokerBaseDevice, count: number, oldCount: number): void;
+    static persistCurrentIllumination(data: CurrentIlluminationDataPoint): void;
+    static readTemperaturDataPoint(hzGrp: HmIpHeizgruppe, limit?: number): Promise<TemperaturDataPoint[]>;
+}

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Persist = void 0;
+const log_service_1 = require("../log-service");
+const logLevel_1 = require("../../../models/logLevel");
+const temperaturDataPoint_1 = require("../../../models/persistence/temperaturDataPoint");
+const todaysCount_1 = require("../../../models/persistence/todaysCount");
+const BasicRoomInfo_1 = require("../../../models/persistence/BasicRoomInfo");
+const RoomDetailInfo_1 = require("../../../models/persistence/RoomDetailInfo");
+const DailyMovementCount_1 = require("../../../models/persistence/DailyMovementCount");
+const mongo_1 = require("meteor/mongo");
+class Persist {
+    static addTemperaturDataPoint(hzGrp) {
+        const dataPoint = new temperaturDataPoint_1.TemperaturDataPoint(hzGrp.info.customName, hzGrp.iTemperatur, hzGrp.desiredTemperatur, hzGrp.iLevel, hzGrp.humidity, new Date());
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Persisting Temperatur Data for ${hzGrp.info.customName}`);
+        this.MeteorBound(() => {
+            this.TemperatureHistoryCollection.insert(dataPoint);
+        });
+        this.MeteorBound(() => {
+            this.HeatGroupCollection.update({ name: dataPoint.name }, dataPoint, { upsert: true });
+        });
+    }
+    static addRoom(room) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Persisting Room for ${room.roomName}`);
+        this.MeteorBound(() => {
+            this.BasicRoomCollection.update({ roomName: room.roomName }, new BasicRoomInfo_1.BasicRoomInfo(room.roomName, room.Settings.etage), {
+                upsert: true,
+            });
+        });
+        const detailed = new RoomDetailInfo_1.RoomDetailInfo(room.roomName, room.Settings.etage);
+        for (const h of room.HeatGroup.heaters) {
+            detailed.heaters.push(h.info.customName);
+        }
+        this.MeteorBound(() => {
+            this.RoomDetailsCollection.update({ roomName: room.roomName }, detailed, { upsert: true });
+        });
+    }
+    static async getCount(device) {
+        const result = new Promise((resolve) => {
+            this.MeteorBound(() => {
+                const options = {
+                    limit: 1,
+                };
+                const databaseValue = this.CountTodayCollection.find({ deviceID: device.info.fullID }, options).fetch();
+                if (databaseValue.length === 0) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Es gibt noch keinen persistierten Counter für ${device.info.fullName}`);
+                    resolve(new todaysCount_1.CountToday(device.info.fullID, 0));
+                }
+                else {
+                    resolve(databaseValue[0]);
+                }
+            });
+        });
+        return result;
+    }
+    static initialize(meteorBound, mongo) {
+        this.MeteorBound = meteorBound;
+        this.Mongo = mongo;
+        this.TemperatureHistoryCollection = new this.Mongo.Collection('TemperaturData');
+        this.HeatGroupCollection = new this.Mongo.Collection('HeatGroupCollection');
+        this.BasicRoomCollection = new this.Mongo.Collection('BasicRooms');
+        this.RoomDetailsCollection = new this.Mongo.Collection('RoomDetailsCollection');
+        this.CountTodayCollection = new this.Mongo.Collection('PresenceToday');
+        this.CurrentIlluminationCollection = new this.Mongo.Collection('CurrentIllumination');
+        this.DailyMovementCountTodayCollection = new this.Mongo.Collection('DailyMovementCount');
+    }
+    static persistTodayCount(device, count, oldCount) {
+        this.MeteorBound(() => {
+            const result = this.CountTodayCollection.update({ deviceID: device.info.fullID }, new todaysCount_1.CountToday(device.info.fullID, count), { upsert: true });
+            if (count === 0) {
+                const date = new Date();
+                date.setHours(-24, 0, 0, 0);
+                const result2 = this.DailyMovementCountTodayCollection.update({ deviceID: device.info.fullID, date: date }, new DailyMovementCount_1.DailyMovementCount(device.info.fullID, oldCount, device.info.room, date), { upsert: true });
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Persisting Daily Movement Count for ${device.info.customName} to ${oldCount} resolved with "${result2}"`);
+            }
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Persisting PresenceToday Data for ${device.info.customName} to ${count} resolved with "${result}"`);
+        });
+    }
+    static persistCurrentIllumination(data) {
+        this.MeteorBound(() => {
+            const result = this.CurrentIlluminationCollection.update({ deviceID: data.deviceID, date: data.date }, data, {
+                upsert: true,
+            });
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Persisting Illumination Data for ${data.deviceID} to ${data.currentIllumination} resolved with "${result}"`);
+        });
+    }
+    static async readTemperaturDataPoint(hzGrp, limit = -1) {
+        const result = new Promise((resolve) => {
+            this.MeteorBound(() => {
+                const options = {
+                    limit: limit > 0 ? limit : undefined,
+                    sort: { date: -1 },
+                };
+                resolve(this.TemperatureHistoryCollection.find({ name: hzGrp.info.customName }, options).fetch());
+            });
+        });
+        return result;
+    }
+}
+exports.Persist = Persist;
+Persist.TemperatureHistoryCollection = new mongo_1.Mongo.Collection('TemperaturData');
+Persist.HeatGroupCollection = new mongo_1.Mongo.Collection('HeatGroupCollection');
+Persist.BasicRoomCollection = new mongo_1.Mongo.Collection('BasicRooms');
+Persist.RoomDetailsCollection = new mongo_1.Mongo.Collection('RoomDetailsCollection');
+Persist.CountTodayCollection = new mongo_1.Mongo.Collection('PresenceToday');
+Persist.CurrentIlluminationCollection = new mongo_1.Mongo.Collection('CurrentIllumination');
+Persist.DailyMovementCountTodayCollection = new mongo_1.Mongo.Collection('DailyMovementCount');

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

@@ -0,0 +1,6 @@
+import { HTTPSOptions } from './HTTPSOptions';
+export declare class HTTPSService {
+    private static defaultCallback;
+    static request(options: HTTPSOptions, postData?: string, retryOnError?: number, responseCallback?: (data: string, statuscode: number) => void): void;
+    static downloadFile(url: string, filePath: string): Promise<boolean>;
+}

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

@@ -0,0 +1,87 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPSService = void 0;
+const log_service_1 = require("./log-service");
+const logLevel_1 = require("../../models/logLevel");
+const fs = __importStar(require("fs"));
+const https_1 = __importDefault(require("https"));
+const utils_1 = require("./utils/utils");
+class HTTPSService {
+    static defaultCallback(data, statuscode) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Response statusCode:"${statuscode}"\nData:"${data}"`);
+    }
+    static request(options, postData = '', retryOnError = 5, responseCallback = HTTPSService.defaultCallback) {
+        const responseData = [];
+        const req = https_1.default.request(options, (res) => {
+            res.on('data', (data) => {
+                responseData.push(data.toString());
+            });
+            res.on('end', () => {
+                responseCallback(responseData.join(''), res.statusCode);
+            });
+        });
+        req.on('error', (e) => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `HTTPS Error: ${e}`);
+            if (retryOnError > 0) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `HTTPS request failed --> ${retryOnError} retries left`);
+                utils_1.Utils.guardedTimeout(() => {
+                    HTTPSService.request(options, postData, retryOnError - 1, responseCallback);
+                }, 100);
+            }
+            else {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `HTTPS request failed after retries`);
+            }
+        });
+        if (postData !== '') {
+            req.write(postData);
+        }
+        req.end();
+    }
+    static async downloadFile(url, filePath) {
+        return new Promise((resolve, reject) => {
+            const file = fs.createWriteStream(filePath);
+            let fileInfo = null;
+            const request = https_1.default.get(url, (response) => {
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Failed to get '${url}' (${response.statusCode})`));
+                    return;
+                }
+                fileInfo = {
+                    mime: response.headers['content-type'],
+                    size: parseInt(response.headers['content-length'], 10),
+                };
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Downloaded File\tType: "${fileInfo.mime}"\tSize:${fileInfo.size}`);
+                response.pipe(file);
+            });
+            // The destination stream is ended by the time it's called
+            file.on('finish', () => resolve(true));
+            request.on('error', (err) => {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Error Downloading File: ${err}`);
+                fs.unlink(filePath, () => resolve(false));
+            });
+        });
+    }
+}
+exports.HTTPSService = HTTPSService;

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

@@ -0,0 +1,12 @@
+export * from './log-service';
+export * from './HTTPSOptions';
+export * from './news-service';
+export * from './https-service';
+export * from './settings-service';
+export * from './time-callback-service';
+export * from './calendar/index';
+export * from './dbo/index';
+export * from './Sonos/index';
+export * from './Telegram/index';
+export * from './utils/index';
+export * from './weather/index';

package/lib/server/services/index.js

@@ -0,0 +1,24 @@
+"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("./log-service"), exports);
+__exportStar(require("./HTTPSOptions"), exports);
+__exportStar(require("./news-service"), exports);
+__exportStar(require("./https-service"), exports);
+__exportStar(require("./settings-service"), exports);
+__exportStar(require("./time-callback-service"), exports);
+__exportStar(require("./calendar/index"), exports);
+__exportStar(require("./dbo/index"), exports);
+__exportStar(require("./Sonos/index"), exports);
+__exportStar(require("./Telegram/index"), exports);
+__exportStar(require("./utils/index"), exports);
+__exportStar(require("./weather/index"), exports);

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

@@ -0,0 +1,14 @@
+import { HmIpDeviceType } from '../devices/hmIPDevices/hmIpDeviceType';
+import { ZigbeeDeviceType } from '../devices/zigbee/zigbeeDeviceType';
+import { LogLevel } from '../../models/logLevel';
+export declare class ServerLogService {
+    static logLevel: number;
+    static telegramLevel: number;
+    static writeLog(pLevel: LogLevel, pMessage: string): void;
+    static addedDeviceToRoom(pRoomName: string, pDeviceType: HmIpDeviceType, pRoomIndex: number, forceDebug?: boolean): void;
+    static missingRoomHandling(pRoomName: string, pDeviceType: HmIpDeviceType): void;
+    static missingRoomIndexHandling(pRoomName: string, pIndex: number, pDeviceType: HmIpDeviceType): void;
+    static addedZigbeeDeviceToRoom(pRoomName: string, pDeviceType: ZigbeeDeviceType, pRoomIndex: number): void;
+    static missingZigbeeRoomHandling(pRoomName: string, pDeviceType: ZigbeeDeviceType): void;
+    static missingZigbeeRoomIndexHandling(pRoomName: string, pIndex: number, pDeviceType: ZigbeeDeviceType): void;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerLogService = void 0;
+const hmIpDeviceType_1 = require("../devices/hmIPDevices/hmIpDeviceType");
+const zigbeeDeviceType_1 = require("../devices/zigbee/zigbeeDeviceType");
+const telegram_service_1 = require("./Telegram/telegram-service");
+const logLevel_1 = require("../../models/logLevel");
+class ServerLogService {
+    static writeLog(pLevel, pMessage) {
+        if (pLevel > ServerLogService.logLevel) {
+            return;
+        }
+        console.log(pMessage);
+        if (pLevel <= ServerLogService.telegramLevel) {
+            const title = logLevel_1.LogLevel[pLevel];
+            telegram_service_1.TelegramService.sendMessage(telegram_service_1.TelegramService.subscribedIDs, `${title}: ${pMessage}`);
+        }
+    }
+    static addedDeviceToRoom(pRoomName, pDeviceType, pRoomIndex, forceDebug = false) {
+        const logLevel = forceDebug ? logLevel_1.LogLevel.Debug : logLevel_1.LogLevel.Trace;
+        ServerLogService.writeLog(logLevel, `${hmIpDeviceType_1.HmIpDeviceType[pDeviceType]} (Raumindex: ${pRoomIndex}) zum Raum "${pRoomName}" hinzugefügt"`);
+    }
+    static missingRoomHandling(pRoomName, pDeviceType) {
+        ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Raum "${pRoomName}" hat keine Definition für den Typ "${hmIpDeviceType_1.HmIpDeviceType[pDeviceType]}"`);
+    }
+    static missingRoomIndexHandling(pRoomName, pIndex, pDeviceType) {
+        ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Raum "${pRoomName}" hat keine Definition für den Typ "${hmIpDeviceType_1.HmIpDeviceType[pDeviceType]} mit Index ${pIndex}"`);
+    }
+    static addedZigbeeDeviceToRoom(pRoomName, pDeviceType, pRoomIndex) {
+        ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `${zigbeeDeviceType_1.ZigbeeDeviceType[pDeviceType]} (Raumindex: ${pRoomIndex}) zum Raum "${pRoomName}" hinzugefügt"`);
+    }
+    static missingZigbeeRoomHandling(pRoomName, pDeviceType) {
+        ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Raum "${pRoomName}" hat keine Definition für den Zigbee Typ "${zigbeeDeviceType_1.ZigbeeDeviceType[pDeviceType]}"`);
+    }
+    static missingZigbeeRoomIndexHandling(pRoomName, pIndex, pDeviceType) {
+        ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Raum "${pRoomName}" hat keine Definition für den Typ "${zigbeeDeviceType_1.ZigbeeDeviceType[pDeviceType]} mit Index ${pIndex}"`);
+    }
+}
+exports.ServerLogService = ServerLogService;
+ServerLogService.logLevel = 4;
+ServerLogService.telegramLevel = -1; // Controlled from within Config File

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

@@ -0,0 +1,10 @@
+import { OwnSonosDevice } from './Sonos/sonos-service';
+export declare class NewsService {
+    static oneDay: number;
+    static lastNewsName: string;
+    private static hourlyInterval;
+    static initialize(): void;
+    static stopHourlyInterval(): void;
+    static getLastNews(): void;
+    static playLastNews(ownSonosDevice: OwnSonosDevice, volume?: number, retries?: number): void;
+}

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

@@ -0,0 +1,90 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewsService = void 0;
+const https_service_1 = require("./https-service");
+const HTTPSOptions_1 = require("./HTTPSOptions");
+const log_service_1 = require("./log-service");
+const logLevel_1 = require("../../models/logLevel");
+const fs = __importStar(require("fs"));
+const sonos_service_1 = require("./Sonos/sonos-service");
+const polly_service_1 = require("./Sonos/polly-service");
+const utils_1 = require("./utils/utils");
+const settings_service_1 = require("./settings-service");
+class NewsService {
+    static initialize() {
+        NewsService.hourlyInterval = utils_1.Utils.guardedInterval(NewsService.getLastNews, 3600000);
+        NewsService.getLastNews();
+    }
+    static stopHourlyInterval() {
+        if (this.hourlyInterval !== undefined) {
+            clearInterval(this.hourlyInterval);
+            this.hourlyInterval = undefined;
+        }
+    }
+    static getLastNews() {
+        https_service_1.HTTPSService.request(new HTTPSOptions_1.HTTPSOptions('www1.wdr.de', '/mediathek/audio/wdr-aktuell-news/index.html', {}, 'GET', 443), '', 5, (response) => {
+            var _a;
+            try {
+                const cutAfterDownload = response.split(`" title="Audio Download">`)[0];
+                const cutsPriorDownload = cutAfterDownload.split(`<a class="button download " href="`);
+                const target = 'https:' + cutsPriorDownload[cutsPriorDownload.length - 1];
+                const splits = target.split('/');
+                const fileName = splits[splits.length - 1];
+                const filePath = `${(_a = settings_service_1.SettingsService.settings.mp3Server) === null || _a === void 0 ? void 0 : _a.path}${fileName}`;
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `NewsService: Die aktuelle News ist "${target}"`);
+                if (fs.existsSync(filePath)) {
+                    NewsService.lastNewsName = fileName.split('.mp3')[0];
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Wir haben bereits die neuste WDR Nachrichten heruntergeladen.`);
+                    return;
+                }
+                https_service_1.HTTPSService.downloadFile(target, `//HOMESERVER/Users/Public/Documents/ttsMP3/${fileName}`).then((success) => {
+                    if (!success) {
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fehler beim Herunterladen der Nachrichten von WDR`);
+                        return;
+                    }
+                    NewsService.lastNewsName = fileName.split('.mp3')[0];
+                });
+            }
+            catch (e) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fehler beim Parsen der WDR Antwort Error: ${e}`);
+                return;
+            }
+        });
+    }
+    static playLastNews(ownSonosDevice, volume = 30, retries = 5) {
+        if (!NewsService.lastNewsName) {
+            if (retries > 0) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Der NewsService ist noch nicht bereit --> warten, verbleibende Neuversuche ${retries - 1}`);
+                utils_1.Utils.guardedTimeout(() => {
+                    NewsService.playLastNews(ownSonosDevice, volume, retries - 1);
+                }, 1000);
+            }
+            else {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Der NewsService ist trotz Warten nicht bereit --> Abbruch`);
+            }
+            return;
+        }
+        sonos_service_1.SonosService.playOnDevice(ownSonosDevice, NewsService.lastNewsName, polly_service_1.PollyService.getDuration(NewsService.lastNewsName), volume);
+    }
+}
+exports.NewsService = NewsService;
+NewsService.oneDay = 1000 * 60 * 60 * 24;

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

@@ -0,0 +1,6 @@
+import { iConfig } from '../config/iConfig';
+export declare class SettingsService {
+    static settings: iConfig;
+    static get TelegramActive(): boolean;
+    static get Mp3Active(): boolean;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsService = void 0;
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const mainConfig_json_1 = __importDefault(require("/src/server/config/private/mainConfig.json"));
+class SettingsService {
+    static get TelegramActive() {
+        return this.settings.telegram !== undefined;
+    }
+    static get Mp3Active() {
+        return this.settings.mp3Server !== undefined;
+    }
+}
+exports.SettingsService = SettingsService;
+SettingsService.settings = mainConfig_json_1.default;

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

@@ -0,0 +1,39 @@
+import { TimeCallback } from '../../models/timeCallback';
+export declare enum TimeOfDay {
+    BeforeSunrise = 1,
+    Daylight = 2,
+    AfterSunset = 3,
+    Night = 4
+}
+export declare class SunTimeOffsets {
+    sunrise: number;
+    sunset: number;
+    minimumHours: number;
+    minimumMinutes: number;
+    maximumHours: number;
+    maximumMinutes: number;
+    constructor(sunrise?: number, sunset?: number, minimumHours?: number, minimumMinutes?: number, maximumHours?: number, maximumMinutes?: number);
+    getNextMinimumSunrise(): Date;
+    getNextMaximumSunset(): Date;
+}
+export declare class TimeCallbackService {
+    private static _todaySunRise;
+    private static _todaySunSet;
+    private static _nextSunRise;
+    private static _nextSunSet;
+    private static _callbacks;
+    private static _iCheck;
+    private static _lastCheck;
+    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;
+}