hoffmation-base 0.1.14 → 0.1.18

package/lib/server/services/Sonos/sonos-service.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosService = exports.OwnSonosDevice = void 0;
+const lib_1 = require("@svrooij/sonos/lib");
+const log_service_1 = require("../log-service");
+const polly_service_1 = require("./polly-service");
+const logLevel_1 = require("../../../models/logLevel");
+const utils_1 = require("../utils/utils");
+const telegram_service_1 = require("../Telegram/telegram-service");
+const timeCallback_1 = require("../../../models/timeCallback");
+const time_callback_service_1 = require("../time-callback-service");
+class OwnSonosDevice {
+    constructor(name, roomName, device) {
+        this.name = name;
+        this.roomName = roomName;
+        this.device = device;
+        this.maxPlayOnAllVolume = 80;
+    }
+    playTestMessage() {
+        SonosService.speakOnDevice(`Ich bin ${this.name}`, this);
+    }
+}
+exports.OwnSonosDevice = OwnSonosDevice;
+class SonosService {
+    static addOwnDevices(snDevices, reinitializationDevice) {
+        this.ownDevices = snDevices;
+        this.reinitializationDevice = reinitializationDevice;
+    }
+    static initialize(reinitialize = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Initialisiere Sonos Service`);
+        if (!reinitialize) {
+            this.checkTimeCallback = new timeCallback_1.TimeCallback('SonosFunctionallityChecker', timeCallback_1.TimeCallbackType.TimeOfDay, () => {
+                this.checkAll();
+            }, 0, 23, 30);
+            time_callback_service_1.TimeCallbackService.addCallback(this.checkTimeCallback);
+        }
+        this.all = [];
+        this.sonosManager = new lib_1.SonosManager();
+        this.sonosManager
+            .InitializeWithDiscovery(10)
+            .then(() => {
+            this.sonosManager.OnNewDevice((d) => {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `SonosDevice ${d.Name} joined`);
+                SonosService.initializeDevice(d);
+            });
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `${this.sonosManager.Devices.length} Sonos Geräte gefunden.`);
+            this.sonosManager.Devices.forEach((d) => {
+                SonosService.initializeDevice(d);
+            });
+            this.isInitialized = true;
+            if (!reinitialize && this.reinitializationDevice !== undefined) {
+                this.speakOnDevice(`Sonos System initialisiert und bereit für Sprachausgaben.`, this.reinitializationDevice, 30);
+            }
+        })
+            .catch(console.error);
+    }
+    static async checkAll() {
+        var _a;
+        let currentDevice;
+        try {
+            for (const deviceName in this.ownDevices) {
+                currentDevice = this.ownDevices[deviceName];
+                if ((currentDevice === null || currentDevice === void 0 ? void 0 : currentDevice.device) === undefined) {
+                    throw `${currentDevice === null || currentDevice === void 0 ? void 0 : currentDevice.name} is missing`;
+                }
+                await currentDevice.device.GetState();
+            }
+            if (currentDevice !== undefined) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Alle Geräte okay --> Last checked ${currentDevice.name}`);
+            }
+        }
+        catch (e) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Atleast one device failed --> Last checked ${(_a = currentDevice === null || currentDevice === void 0 ? void 0 : currentDevice.name) !== null && _a !== void 0 ? _a : 'undefined'}`);
+            telegram_service_1.TelegramService.inform(`Sonos device is failing --> Reinitialize whole system`);
+            this.initialize(true);
+        }
+    }
+    static speakOnAll(pMessage, volumeOverride = -1) {
+        if (!this.isInitialized) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `SonosService noch nicht initialisiert.`);
+        }
+        polly_service_1.PollyService.tts(pMessage, (networkPath, duration) => {
+            const hours = new Date().getHours();
+            const volume = hours < 10 || hours > 22 ? 40 : 80;
+            for (const deviceName in this.ownDevices) {
+                SonosService.playOnDevice(this.ownDevices[deviceName], networkPath, duration, volumeOverride > -1 ? volumeOverride : Math.min(volume, this.ownDevices[deviceName].maxPlayOnAllVolume));
+            }
+        });
+    }
+    static playOnDevice(ownSnDevice, mp3Name, duration, volume = undefined, onlyWhenPlaying = undefined, resolveAfterRevert = false) {
+        const specificTimeout = Math.ceil(duration / 1000) + 5;
+        const options = {
+            trackUri: `http://192.168.178.13:8081/file.mp3?fname=${mp3Name}`,
+            delayMs: 750,
+            onlyWhenPlaying: onlyWhenPlaying,
+            resolveAfterRevert: resolveAfterRevert,
+            volume: volume,
+            specificTimeout: specificTimeout,
+            notificationFired: (played) => {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Sonos Notification ("${mp3Name}") was${played ? '' : "n't"} played in ${ownSnDevice.roomName} (duration: "${specificTimeout}")`);
+            },
+        };
+        try {
+            const device = ownSnDevice.device;
+            if (device === undefined) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Sonos Geräte ${ownSnDevice.name} ist nicht initialisiert`);
+                utils_1.Utils.guardedTimeout(() => {
+                    this.initialize();
+                }, 500, this);
+                return;
+            }
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Spiele nun die Ausgabe für "${mp3Name}" auf "${ownSnDevice.name}"`);
+            device.PlayNotificationTwo(options).then((played) => {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Sonos Notification ("${mp3Name}") was${played ? '' : "n't"} played in ${ownSnDevice.roomName} (duration: "${specificTimeout}")`);
+            });
+        }
+        catch (err) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Sonos Error ${err.message}: ${err.stack}`);
+        }
+    }
+    static speakOnDevice(pMessage, ownSnDevice, volume = undefined, onlyWhenPlaying = undefined, resolveAfterRevert = undefined) {
+        polly_service_1.PollyService.tts(pMessage, (networkPath, duration) => {
+            SonosService.playOnDevice(ownSnDevice, networkPath, duration, volume, onlyWhenPlaying, resolveAfterRevert);
+        });
+    }
+    static speakTestMessageOnEachDevice() {
+        for (const deviceName in this.ownDevices) {
+            this.ownDevices[deviceName].playTestMessage();
+        }
+    }
+    static initializeDevice(d) {
+        this.devicesDict[d.Name] = d;
+        this.ownDevices[d.Name].device = d;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Sonos ${d.Uuid} für ${d.Name} gefunden`);
+    }
+}
+exports.SonosService = SonosService;
+SonosService.ownDevices = {};
+SonosService.all = [];
+SonosService.devicesDict = {};

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

@@ -0,0 +1,3 @@
+export * from './telegram-service';
+export * from './telegram-Commands';
+export * from './telegramMessageCalback';

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

@@ -0,0 +1,15 @@
+"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("./telegram-service"), exports);
+__exportStar(require("./telegram-Commands"), exports);
+__exportStar(require("./telegramMessageCalback"), exports);

package/lib/server/services/Telegram/telegram-Commands.d.ts

@@ -0,0 +1,3 @@
+export declare class TelegramCommands {
+    static initialize(): void;
+}

package/lib/server/services/Telegram/telegram-Commands.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramCommands = void 0;
+const devices_1 = require("../../devices/devices");
+const telegram_service_1 = require("./telegram-service");
+const telegramMessageCalback_1 = require("./telegramMessageCalback");
+const Griffe_1 = require("../../devices/Griffe");
+const Heizgruppen_1 = require("../../devices/Heizgruppen");
+const Rollos_1 = require("../../devices/Rollos");
+const zigbeeDeviceType_1 = require("../../devices/zigbee/zigbeeDeviceType");
+const RoomBase_1 = require("../../../models/rooms/RoomBase");
+const sonos_service_1 = require("../Sonos/sonos-service");
+const hmIpDeviceType_1 = require("../../devices/hmIPDevices/hmIpDeviceType");
+class TelegramCommands {
+    static initialize() {
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AlarmStop', /\/stop_alarm/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            RoomBase_1.RoomBase.clearAllAlarms();
+            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Alle ausgelösten Wasser-/Rauchmelder und Eindringlingsalarme wurden gestoppt.');
+            return true;
+        }, 'Eine Möglichkeit bei Fehlalarm den Alarm abzuschalten'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AwayModeStart', /\/away_mode_start/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            RoomBase_1.RoomBase.startAwayMode();
+            telegram_service_1.TelegramService.inform('Der Abwesenheitsmodus ist initiiert');
+            return true;
+        }, 'Eine Möglichkeit die Alarmanlage scharfzuschalten'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('NightAlarmMode', /\/nightalarm_mode_start/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            RoomBase_1.RoomBase.startNightAlarmMode();
+            telegram_service_1.TelegramService.inform('Der Nachtmodus ist initiiert');
+            return true;
+        }, 'Alarmanlage für die Nacht scharf schalten'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AlarmModesEnd', /\/alarm_modes_end/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            RoomBase_1.RoomBase.endAlarmModes();
+            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Der Abwesenheitsmodus ist deaktiviert.');
+            return true;
+        }, 'Alarmanlage nach Abwesenheit/Nacht entschärfen'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('LastMovements', /\/check_movement/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.from.id], `Im Folgenden sind die letzten Bewegungen\n${RoomBase_1.RoomBase.getLastMovements()}`);
+            return true;
+        }, 'Gibt die letzten Bewegungen inkl. ihrer Uhrzeit aus.'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('TelegramTest', /\/test/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Hallo, ich bin der HoffMation Bot.');
+            return true;
+        }, 'Eine Möglichkeit die Verknüpfung mit dem HoffMation Bot zu testen'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('RolloObenCheck', /\/check_rollo/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.from.id], Rollos_1.Rolladen.getRolladenPosition());
+            return true;
+        }, 'Gibt die Positionen der Rollos aus, warnt über offene Rollos und nennt die nächsten Fahrten'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('FensterCheck', /\/check_fenster/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.from.id], Griffe_1.Griffe.getGriffPosition());
+            return true;
+        }, 'Gibt die Positionen der Fenstergriffe aus und warnt somit über offene Fenster'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('HeizungCheck', /\/check_temperatur/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.from.id], Heizgruppen_1.Heizgruppen.getInfo());
+            return true;
+        }, 'Gibt die Namen und aktuellen Werte sämtlicher Heizgruppen aus (aktuelle Temperatur, Soll Temperatur, Ventilstellung).'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('HeizungError', /\/temperatur_error/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.from.id], Heizgruppen_1.Heizgruppen.getProblems());
+            return true;
+        }, 'Zeigt Differenzen zwischen Heizungen und den jeweiligen Heizgruppen auf'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('HeizungCheckOne', /\/check_1_temperatur.*/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.from.id], await Heizgruppen_1.Heizgruppen.getSpecificInfo(m.text));
+            return true;
+        }, `Gibt den Verlauf der in \\"\\" übergebenen Heizgruppe aus.`, /\/check_1_temperatur/));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AllRolloDown', /\/all_rollo_down/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            RoomBase_1.RoomBase.setAllRolloOfFloor(-1, 0);
+            telegram_service_1.TelegramService.sendMessage([m.from.id], `Es werden alle Rollos heruntergefahren`);
+            return true;
+        }, `Fährt alle rollos runter`));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('VibrationSensitivity', /\/set_vibration_sensitivity/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            for (const id in devices_1.Devices.Zigbee) {
+                const d = devices_1.Devices.Zigbee[id];
+                if (d.deviceType === zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeAquaraVibra) {
+                    d.setSensitivity(2);
+                }
+            }
+            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Abgeschlossen');
+            return true;
+        }, `Setzt alle Vibrationsensoren auf High`));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AllButtonAssignments', /\/get_all_button_assignments/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            const response = ['These are the assignments for all buttons'];
+            for (const id in devices_1.Devices.hmIP) {
+                const d = devices_1.Devices.hmIP[id];
+                if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpTaster) {
+                    response.push(d.getTastenAssignment());
+                }
+            }
+            telegram_service_1.TelegramService.sendMessage([m.from.id], response.join('\n'));
+            return true;
+        }, `Retrieves the button assignments for all buttons in home`));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('SonosTest', /\/perform_sonos_test/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            sonos_service_1.SonosService.speakTestMessageOnEachDevice();
+            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Testnachricht gesprochen --> Führe weiteren Test durch');
+            sonos_service_1.SonosService.checkAll();
+            return true;
+        }, `Spiele eine kurze Nachricht auf allen Sonos Geräten um diese zu identifizieren`));
+    }
+}
+exports.TelegramCommands = TelegramCommands;

package/lib/server/services/Telegram/telegram-service.d.ts

@@ -0,0 +1,19 @@
+import TelegramBot from 'node-telegram-bot-api';
+import { TelegramMessageCallback } from './telegramMessageCalback';
+import { iTelegramSettings } from '../../config/iConfig';
+export declare class TelegramService {
+    static subscribedIDs: number[];
+    private static token;
+    private static active;
+    private static bot;
+    private static allowedIDs;
+    private static settings;
+    private static callbacks;
+    static addMessageCallback(pCallback: TelegramMessageCallback, reset?: boolean): void;
+    static initialize(settings?: iTelegramSettings): void;
+    static publishCommands(): void;
+    static inform(message: string): void;
+    static sendMessage(ids: number[], message: string): void;
+    static checkAuthorized(msg: TelegramBot.Message): boolean;
+    static resetMessageCallbacks(): void;
+}

package/lib/server/services/Telegram/telegram-service.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramService = void 0;
+const node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
+const log_service_1 = require("../log-service");
+const telegramMessageCalback_1 = require("./telegramMessageCalback");
+const logLevel_1 = require("../../../models/logLevel");
+const utils_1 = require("../utils/utils");
+class TelegramService {
+    static addMessageCallback(pCallback, reset = false) {
+        if (!reset) {
+            TelegramService.callbacks[pCallback.name] = pCallback;
+        }
+        TelegramService.bot.onText(pCallback.identifier, (msg) => {
+            if (!TelegramService.checkAuthorized(msg)) {
+                return;
+            }
+            pCallback.callback(msg);
+        });
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Telegram Callback mit Namen ${pCallback.name} für Nachrichten mit "${pCallback.identifier}" hinzugefügt`);
+    }
+    static initialize(settings) {
+        if (!settings && this.settings === undefined) {
+            this.active = false;
+            return;
+        }
+        if (settings) {
+            this.settings = settings;
+            log_service_1.ServerLogService.telegramLevel = settings.logLevel;
+            this.token = settings.telegramToken;
+            this.allowedIDs = settings.allowedIDs;
+            this.subscribedIDs = settings.subscribedIDs;
+        }
+        this.active = true;
+        this.bot = new node_telegram_bot_api_1.default(this.token, { polling: true, webHook: false });
+        this.bot.on('polling_error', (e) => {
+            /*
+            if (!this.reinitiliazeWithTimeout()) {
+              return;
+            }
+             */
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Telegram Polling Error: ${e.message}`);
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Telegram Polling Error stack: ${e.stack}`);
+        });
+        TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('helpCommand', /\/help/, async (m) => {
+            var _a;
+            if (m.from === undefined)
+                return true;
+            const message = [];
+            message.push('Im folgenden ist eine Liste sämtlicher Kommandos:\n');
+            for (const cName in TelegramService.callbacks) {
+                const telegramCb = TelegramService.callbacks[cName];
+                message.push(`${telegramCb.identifier.toString().replace(/\//g, '').replace(/\\/g, '')} - ${telegramCb.helpMessage}`);
+            }
+            TelegramService.sendMessage([(_a = m.from) === null || _a === void 0 ? void 0 : _a.id], message.join('\n'));
+            return true;
+        }, `Gibt eine Liste mit sämtlichen Kommandos aus`));
+        TelegramService.inform(`(Re-)Initialisierung abgeschlossen`);
+    }
+    static publishCommands() {
+        const commands = [];
+        for (const cName in TelegramService.callbacks) {
+            const telegramCb = TelegramService.callbacks[cName];
+            const commandIdentifier = (telegramCb.identifierForCommandList !== undefined ? telegramCb.identifierForCommandList : telegramCb.identifier)
+                .toString()
+                .replace(/\//g, '')
+                .replace(/\\/g, '');
+            commands.push({ command: commandIdentifier, description: telegramCb.helpMessage });
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `New Telegram Commands: "${JSON.stringify(commands)}"`);
+        TelegramService.bot.setMyCommands(commands);
+    }
+    static inform(message) {
+        this.sendMessage(this.subscribedIDs, message);
+    }
+    static sendMessage(ids, message) {
+        if (!TelegramService.active) {
+            // We can't use Log Service here, as it might result in a recursion
+            console.log(`Telegram message ${message} wasn't send as TelegramService is inactive`);
+            return;
+        }
+        const chunksNeeded = Math.ceil(message.length / 4095);
+        for (let i = 0; i < chunksNeeded; i++) {
+            for (const id of ids) {
+                utils_1.Utils.guardedTimeout(() => {
+                    this.bot.sendMessage(id, message.substring(i * 4095, i * 4095 + 4095)).catch((r) => {
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Send Telegram Message to ${id} failed: ${r}`);
+                    });
+                }, 200 * i, this);
+            }
+        }
+    }
+    static checkAuthorized(msg) {
+        var _a;
+        if (msg.from !== undefined && this.allowedIDs.includes((_a = msg.from) === null || _a === void 0 ? void 0 : _a.id)) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Authorisierte Telegram Message erhalten: ${JSON.stringify(msg)}`);
+            return true;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Fremden Telegram Nutzer erkannt. Nachricht "${JSON.stringify(msg)}"`);
+        TelegramService.sendMessage([msg.chat.id], "Hello stranger,\nExcuse me, but you're not yet on the guest list.\nPlease contact our manager.\nHave a great day");
+        return false;
+    }
+    /*
+    private static reinitialize(): void {
+      ServerLogService.writeLog(LogLevel.Info, `Reinitialize Telegram Bot: Stop Polling`);
+      this.bot
+        .startPolling({ restart: true })
+        .then(() => {
+          this.restartTimeout = undefined;
+          this.resetMessageCallbacks();
+          ServerLogService.writeLog(LogLevel.Debug, `Reinitialization of Telegram finished.`);
+        })
+        .catch((e) => {
+          ServerLogService.writeLog(LogLevel.Info, `Can't start polling: ${e}`);
+          TelegramService.reinitiliazeWithTimeout(true);
+        });
+    }
+  
+    public static reinitiliazeWithTimeout(force: boolean = false): boolean {
+      if (this.restartTimeout !== undefined && !force) {
+        return false;
+      } else if (force && this.restartTimeout !== undefined) {
+        clearTimeout(this.restartTimeout);
+      }
+  
+      this.restartTimeout = Utils.guardedTimeout(
+        () => {
+          this.reinitialize();
+        },
+        10000,
+        this,
+      );
+      return true;
+    }
+    */
+    static resetMessageCallbacks() {
+        TelegramService.bot.clearTextListeners();
+        for (const name in TelegramService.callbacks) {
+            this.addMessageCallback(TelegramService.callbacks[name]);
+        }
+    }
+}
+exports.TelegramService = TelegramService;
+TelegramService.active = false;
+TelegramService.settings = undefined;
+// private static restartTimeout: NodeJS.Timeout | undefined = undefined;
+TelegramService.callbacks = {};

package/lib/server/services/Telegram/telegramMessageCalback.d.ts

@@ -0,0 +1,9 @@
+import TelegramBot from 'node-telegram-bot-api';
+export declare class TelegramMessageCallback {
+    name: string;
+    identifier: RegExp;
+    callback: (message: TelegramBot.Message) => Promise<boolean>;
+    helpMessage: string;
+    identifierForCommandList?: RegExp | undefined;
+    constructor(name: string, identifier: RegExp, callback: (message: TelegramBot.Message) => Promise<boolean>, helpMessage: string, identifierForCommandList?: RegExp | undefined);
+}

package/lib/server/services/Telegram/telegramMessageCalback.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramMessageCallback = void 0;
+class TelegramMessageCallback {
+    constructor(name, identifier, callback, helpMessage, identifierForCommandList) {
+        this.name = name;
+        this.identifier = identifier;
+        this.callback = callback;
+        this.helpMessage = helpMessage;
+        this.identifierForCommandList = identifierForCommandList;
+    }
+}
+exports.TelegramMessageCallback = TelegramMessageCallback;

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

@@ -0,0 +1,2 @@
+export * from './muell-tonne';
+export * from './müll-service';

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

@@ -0,0 +1,14 @@
+"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("./muell-tonne"), exports);
+__exportStar(require("./m\u00FCll-service"), exports);

package/lib/server/services/calendar/muell-tonne.d.ts

@@ -0,0 +1,12 @@
+import { OwnSonosDevice } from '../Sonos/sonos-service';
+export declare class MuellTonne {
+    name: string;
+    ownSonosDevice?: OwnSonosDevice | undefined;
+    static oneDay: number;
+    nextDate: Date | undefined;
+    dates: Date[];
+    constructor(name: string, ownSonosDevice?: OwnSonosDevice | undefined);
+    sortDates(): void;
+    removePassedDates(): void;
+    check(): void;
+}

package/lib/server/services/calendar/muell-tonne.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MuellTonne = void 0;
+const sonos_service_1 = require("../Sonos/sonos-service");
+const log_service_1 = require("../log-service");
+const logLevel_1 = require("../../../models/logLevel");
+const telegram_service_1 = require("../Telegram/telegram-service");
+class MuellTonne {
+    constructor(name, ownSonosDevice) {
+        this.name = name;
+        this.ownSonosDevice = ownSonosDevice;
+        this.nextDate = undefined;
+        this.dates = [];
+    }
+    sortDates() {
+        this.dates = this.dates.sort((a, b) => a.getTime() - b.getTime());
+        this.removePassedDates();
+        if (this.nextDate !== undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Die "${this.name}" ist das nächste mal am ${this.nextDate.toLocaleDateString('de-DE')} zu leeren`);
+        }
+    }
+    removePassedDates() {
+        const todayMidnight = new Date().setHours(0, 0, 0, 0);
+        while (this.dates.length > 0 && this.dates[0].getTime() < todayMidnight) {
+            this.dates.shift();
+        }
+        this.nextDate = this.dates[0];
+    }
+    check() {
+        this.removePassedDates();
+        if (this.nextDate === undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `Die Mülltonne mit dem Namen ${this.name} hat keine nächste Abholung!`);
+            return;
+        }
+        const todayMidnight = new Date().setHours(0, 0, 0, 0);
+        const tomorowMidnight = todayMidnight + MuellTonne.oneDay;
+        const tomorowAfterMidnight = tomorowMidnight + MuellTonne.oneDay;
+        const nextTimestamp = this.nextDate.getTime();
+        const daysTilNextEvent = (nextTimestamp - todayMidnight) / MuellTonne.oneDay;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Die Mülltonne mit dem Namen ${this.name} wird in ${daysTilNextEvent} Tagen das nächste Mal abgeholt.`);
+        if (nextTimestamp >= tomorowAfterMidnight) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Die Mülltonne mit dem Namen ${this.name} wird erst nach Übermorgen abgeholt`);
+            return; // Es ist noch lange hin
+        }
+        if (nextTimestamp >= tomorowMidnight) {
+            const message = `Die Mülltonne mit dem Namen ${this.name} wird morgen abgeholt!`;
+            telegram_service_1.TelegramService.inform(message);
+            if (this.ownSonosDevice) {
+                sonos_service_1.SonosService.speakOnDevice(message, this.ownSonosDevice, 30);
+            }
+            return;
+        }
+        if (nextTimestamp >= todayMidnight) {
+            if (new Date().getHours() > 10) {
+                const message = `Die Mülltonne mit dem Namen ${this.name} wurde heute abgeholt, Mülltonne zurückstellen!`;
+                telegram_service_1.TelegramService.inform(message);
+                if (this.ownSonosDevice) {
+                    sonos_service_1.SonosService.speakOnDevice(message, this.ownSonosDevice, 30);
+                }
+            }
+            else {
+                const message = `Die Mülltonne mit dem Namen ${this.name} wird heute abgeholt!`;
+                telegram_service_1.TelegramService.inform(message);
+                if (this.ownSonosDevice) {
+                    sonos_service_1.SonosService.speakOnDevice(message, this.ownSonosDevice, 30);
+                }
+            }
+            return;
+        }
+    }
+}
+exports.MuellTonne = MuellTonne;
+MuellTonne.oneDay = 1000 * 60 * 60 * 24;

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

@@ -0,0 +1,24 @@
+import { TimeCallback } from '../../../models/timeCallback';
+import { iMuellSettings } from '../../config/iConfig';
+import { MuellTonne } from './muell-tonne';
+import { OwnSonosDevice } from '../Sonos/sonos-service';
+export declare class MuellService {
+    static alleTonnen: Array<{
+        name: string;
+        date: Date;
+    }>;
+    static blaueTonne: MuellTonne;
+    static graueTonne: MuellTonne;
+    static gelbeTonne: MuellTonne;
+    static brauneTonne: MuellTonne;
+    static updateTimeCallback: TimeCallback;
+    static checkTimeCallback: TimeCallback;
+    private static lastCheck;
+    private static _calendarURL;
+    private static _active;
+    private static defaultSonosDevice;
+    static months: string[];
+    static intialize(config: iMuellSettings, defaultSonosDevice: OwnSonosDevice | undefined): void;
+    static updateCalendar(checkAfterwards?: boolean): void;
+    static checkAll(pRetries?: number): void;
+}