hoffmation-base 3.0.2 → 3.1.0

package/lib/services/Sonos/own-sonos-device.d.ts

@@ -0,0 +1,31 @@
+import { DeviceCapability, DeviceType, LogDebugType, LogLevel } from '../../enums';
+import { iRoomBase, iSpeaker } from '../../interfaces';
+import { DeviceInfo, SonosDeviceSettings } from '../../devices';
+import { SonosDevice } from '@svrooij/sonos/lib';
+export declare class OwnSonosDevice implements iSpeaker {
+    device: SonosDevice | undefined;
+    /** @inheritDoc */
+    settings: SonosDeviceSettings;
+    /** @inheritDoc */
+    readonly deviceType: DeviceType;
+    /** @inheritDoc */
+    readonly discoveryName: string;
+    /** @inheritDoc */
+    readonly deviceCapabilities: DeviceCapability[];
+    get customName(): string;
+    constructor(discoveryName: string, roomName: string, device: SonosDevice | undefined);
+    protected _info: DeviceInfo;
+    get info(): DeviceInfo;
+    get room(): iRoomBase | undefined;
+    get id(): string;
+    get name(): string;
+    playOnDevice(mp3Name: string, duration: number, volume?: number | undefined, onlyWhenPlaying?: boolean | undefined, resolveAfterRevert?: boolean | undefined): void;
+    playTestMessage(): void;
+    speakOnDevice(pMessage: string, volume?: number | undefined, onlyWhenPlaying?: boolean | undefined, resolveAfterRevert?: boolean | undefined): void;
+    stop(): void;
+    playUrl(url: string): void;
+    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    toJSON(): Partial<OwnSonosDevice>;
+    persistDeviceInfo(): void;
+    loadDeviceSettings(): void;
+}

package/lib/services/Sonos/own-sonos-device.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnSonosDevice = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const enums_1 = require("../../enums");
+const devices_1 = require("../../devices");
+const api_1 = require("../../api");
+const settings_service_1 = require("../../settings-service");
+const logging_1 = require("../../logging");
+const utils_1 = require("../../utils");
+const sonos_service_1 = require("./sonos-service");
+const polly_service_1 = require("./polly-service");
+const dbo_1 = require("../dbo");
+class OwnSonosDevice {
+    get customName() {
+        return this.info.customName;
+    }
+    constructor(discoveryName, roomName, device) {
+        this.device = device;
+        /** @inheritDoc */
+        this.settings = new devices_1.SonosDeviceSettings();
+        /** @inheritDoc */
+        this.deviceType = enums_1.DeviceType.Sonos;
+        /** @inheritDoc */
+        this.deviceCapabilities = [enums_1.DeviceCapability.speaker];
+        this.discoveryName = discoveryName;
+        this._info = new devices_1.DeviceInfo();
+        this._info.fullName = `Sonos ${roomName} ${discoveryName}`;
+        this._info.customName = `Sonos ${discoveryName}`;
+        this._info.room = roomName;
+        this._info.allDevicesKey = `sonos-${roomName}-${discoveryName}`;
+        devices_1.Devices.alLDevices[`sonos-${roomName}-${discoveryName}`] = this;
+        this.persistDeviceInfo();
+        this.loadDeviceSettings();
+    }
+    get info() {
+        return this._info;
+    }
+    get room() {
+        return api_1.API.getRoom(this.info.room);
+    }
+    get id() {
+        var _a;
+        return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `sonos-${this.info.room}-${this.info.customName}`;
+    }
+    get name() {
+        return this.info.customName;
+    }
+    playOnDevice(mp3Name, duration, volume = undefined, onlyWhenPlaying = undefined, resolveAfterRevert = false) {
+        var _a, _b;
+        if (((_a = settings_service_1.SettingsService.settings.mp3Server) === null || _a === void 0 ? void 0 : _a.serverAddress) === undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Alert, "Sonos: Can't speak as we have no mp3Server");
+            return;
+        }
+        const specificTimeout = Math.ceil(duration / 1000) + 5;
+        const options = {
+            catchQueueErrors: true,
+            trackUri: `${(_b = settings_service_1.SettingsService.settings.mp3Server) === null || _b === void 0 ? void 0 : _b.serverAddress}/file.mp3?fname=${mp3Name}`,
+            delayMs: 750,
+            onlyWhenPlaying: onlyWhenPlaying,
+            resolveAfterRevert: resolveAfterRevert,
+            volume: volume,
+            specificTimeout: specificTimeout,
+            notificationFired: (played) => {
+                this.log(enums_1.LogLevel.Trace, `Sonos Notification ("${mp3Name}") was${played ? '' : "n't"} played (duration: "${specificTimeout}")`);
+            },
+        };
+        try {
+            if (this.device === undefined) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Alert, `Sonos Geräte ${this.name} ist nicht initialisiert`);
+                utils_1.Utils.guardedTimeout(() => {
+                    sonos_service_1.SonosService.initialize();
+                }, 500, this);
+                return;
+            }
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, `Spiele nun die Ausgabe für "${mp3Name}" auf "${this.name}"`);
+            this.device.PlayNotificationTwo(options).then((played) => {
+                this.log(enums_1.LogLevel.Debug, `Sonos Notification ("${mp3Name}") was${played ? '' : "n't"} played (duration: "${specificTimeout}")`);
+            });
+        }
+        catch (err) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Sonos Error ${err.message}: ${err.stack}`);
+        }
+    }
+    playTestMessage() {
+        this.speakOnDevice(`Ich bin ${this.name}`);
+    }
+    speakOnDevice(pMessage, volume = undefined, onlyWhenPlaying = undefined, resolveAfterRevert = undefined) {
+        polly_service_1.PollyService.tts(pMessage, (networkPath, duration) => {
+            this.playOnDevice(networkPath, duration, volume, onlyWhenPlaying, resolveAfterRevert);
+        });
+    }
+    stop() {
+        var _a;
+        (_a = this.device) === null || _a === void 0 ? void 0 : _a.Stop();
+    }
+    playUrl(url) {
+        var _a;
+        (_a = this.device) === null || _a === void 0 ? void 0 : _a.SetAVTransportURI(url);
+    }
+    log(level, message, debugType = enums_1.LogDebugType.None) {
+        var _a, _b;
+        logging_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
+            debugType: debugType,
+            room: (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.roomName) !== null && _b !== void 0 ? _b : '',
+            deviceId: this.name,
+            deviceName: this.name,
+        });
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, ['room']));
+    }
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = dbo_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    loadDeviceSettings() {
+        this.settings.initializeFromDb(this);
+    }
+}
+exports.OwnSonosDevice = OwnSonosDevice;

package/lib/services/Sonos/polly-service.d.ts

@@ -0,0 +1,18 @@
+import AWS from 'aws-sdk';
+import { iPollySettings } from '../../interfaces';
+export declare class PollyService {
+    /**
+     * Whether Polly-Service is active
+     */
+    static active: boolean;
+    /**
+     * The API Instance
+     */
+    static polly: AWS.Polly;
+    private static _voice;
+    private static _mp3Path;
+    static initialize(config: iPollySettings): void;
+    static getDuration(filename: string): number;
+    static preloadTTS(text: string): void;
+    static tts(text: string, cb: (fileLink: string, duration: number) => void): void;
+}

package/lib/services/Sonos/polly-service.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.PollyService = void 0;
+const aws_sdk_1 = __importDefault(require("aws-sdk"));
+const fs = __importStar(require("fs"));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const get_mp3_duration_1 = __importDefault(require("get-mp3-duration"));
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const logging_1 = require("../../logging");
+const enums_1 = require("../../enums");
+class PollyService {
+    static initialize(config) {
+        this.active = true;
+        this._mp3Path = config.mp3Path;
+        this.polly = new aws_sdk_1.default.Polly({
+            region: config.region,
+            signatureVersion: config.signatureVersion,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            },
+        });
+        this._voice = config.voiceID;
+    }
+    static getDuration(filename) {
+        const fPath = path_1.default.join(this._mp3Path, filename);
+        try {
+            if (fs.existsSync(fPath)) {
+                return (0, get_mp3_duration_1.default)(fs.readFileSync(fPath));
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+        return 1800000;
+    }
+    static preloadTTS(text) {
+        if (!this.active) {
+            return;
+        }
+        this.tts(text, (link, duration) => {
+            if (duration <= 0) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Retrieving tts for "${text}" failed as duration is 0 or lower`);
+            }
+            else if (!link) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Retrieving tts for "${text}" failed as link is empty`);
+            }
+        });
+    }
+    static tts(text, cb) {
+        const hash = `${this._voice}_${crypto_1.default.createHash('md5').update(text).digest('hex')}`;
+        const fPath = `${this._mp3Path}${hash}.mp3`;
+        try {
+            if (fs.existsSync(fPath)) {
+                const duration = (0, get_mp3_duration_1.default)(fs.readFileSync(fPath));
+                cb(hash, duration);
+                return;
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, `Für die Nachricht "${text}" fehlt die TTS --> bei AWS anfragen`);
+        const params = {
+            Text: text,
+            OutputFormat: 'mp3',
+            VoiceId: this._voice,
+        };
+        this.polly.synthesizeSpeech(params, (err, data) => {
+            if (err) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `AWS Polly Error: ${err}`);
+                return;
+            }
+            if (!data || data.AudioStream === undefined) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, "AWS Polly didn't send any data");
+                return;
+            }
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, `AWS Antwort für (${hash}) erhalten Text: "${text}"`);
+            fs.writeFile(fPath, data.AudioStream, (err) => {
+                const duration = (0, get_mp3_duration_1.default)(data.AudioStream);
+                if (err) {
+                    logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, 'AWS Polly: Saving failed');
+                    return;
+                }
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, 'AWS Polly: Saving sucessfully');
+                cb(hash, duration);
+                return;
+            });
+        });
+    }
+}
+exports.PollyService = PollyService;
+/**
+ * Whether Polly-Service is active
+ */
+PollyService.active = false;

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosService = void 0;
+const enums_1 = require("../../enums");
+const logging_1 = require("../../logging");
+const lib_1 = require("@svrooij/sonos/lib");
+const models_1 = require("../../models");
+const settings_service_1 = require("../../settings-service");
+const time_callback_service_1 = require("../time-callback-service");
+const Telegram_1 = require("../Telegram");
+const polly_service_1 = require("./polly-service");
+class SonosService {
+    static get config() {
+        return settings_service_1.SettingsService.settings.sonos;
+    }
+    static addOwnDevices(snDevices, reinitializationDevice) {
+        this.ownDevices = snDevices;
+        this.reinitializationDevice = reinitializationDevice;
+    }
+    static initialize(reinitialize = false) {
+        var _a, _b;
+        if (((_a = settings_service_1.SettingsService.settings.mp3Server) === null || _a === void 0 ? void 0 : _a.serverAddress) === undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Alert, 'SonosService needs properly configured mp3Server.');
+        }
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, 'Initialisiere Sonos Service');
+        if (!reinitialize) {
+            this.checkTimeCallback = new models_1.TimeCallback('SonosFunctionallityChecker', enums_1.TimeCallbackType.TimeOfDay, () => {
+                void this.checkAll();
+            }, 0, 23, 30);
+            time_callback_service_1.TimeCallbackService.addCallback(this.checkTimeCallback);
+            Telegram_1.TelegramService.addMessageCallback(new Telegram_1.TelegramMessageCallback('SonosTest', /\/perform_sonos_test/, async (m) => {
+                if (m.from === undefined)
+                    return false;
+                SonosService.speakTestMessageOnEachDevice();
+                Telegram_1.TelegramService.sendMessage([m.chat.id], 'Testnachricht gesprochen --> Führe weiteren Test durch');
+                await SonosService.checkAll();
+                return true;
+            }, 'Spiele eine kurze Nachricht auf allen Sonos Geräten um diese zu identifizieren'));
+        }
+        this.sonosManager = new lib_1.SonosManager();
+        this.sonosManager.OnNewDevice((d) => {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `SonosDevice ${d.Name} joined`);
+            SonosService.initializeDevice(d);
+        });
+        const initialHost = (_b = this.config) === null || _b === void 0 ? void 0 : _b.initialHost;
+        (initialHost === undefined
+            ? this.sonosManager.InitializeWithDiscovery(10)
+            : this.sonosManager.InitializeFromDevice(initialHost))
+            .then(() => {
+            var _a;
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, `${this.sonosManager.Devices.length} Sonos Geräte gefunden.`);
+            this.sonosManager.Devices.forEach((d) => {
+                SonosService.initializeDevice(d);
+            });
+            this.isInitialized = true;
+            if (!reinitialize) {
+                (_a = this.reinitializationDevice) === null || _a === void 0 ? void 0 : _a.speakOnDevice('Sonos System initialisiert und bereit für Sprachausgaben.', 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) {
+                    // noinspection ExceptionCaughtLocallyJS
+                    throw `${currentDevice === null || currentDevice === void 0 ? void 0 : currentDevice.name} is missing`;
+                }
+                await currentDevice.device.GetState();
+            }
+            if (currentDevice !== undefined) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Alle Geräte okay --> Last checked ${currentDevice.name}`);
+            }
+        }
+        catch (_e) {
+            logging_1.ServerLogService.writeLog(enums_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_1.TelegramService.inform('Sonos device is failing --> Reinitialize whole system');
+            this.initialize(true);
+        }
+    }
+    static speakOnAll(pMessage, volumeOverride = -1) {
+        if (!this.isInitialized) {
+            logging_1.ServerLogService.writeLog(enums_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) {
+                this.ownDevices[deviceName].playOnDevice(networkPath, duration, volumeOverride > -1
+                    ? volumeOverride
+                    : Math.min(volume, this.ownDevices[deviceName].settings.maxPlayOnAllVolume));
+            }
+        });
+    }
+    static speakTestMessageOnEachDevice() {
+        for (const deviceName in this.ownDevices) {
+            this.ownDevices[deviceName].playTestMessage();
+        }
+    }
+    static initializeDevice(d) {
+        if (this.ownDevices[d.Name] === undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Alert, `Unbekanntes Sonos Gerät "${d.Name}"`);
+            return;
+        }
+        this.ownDevices[d.Name].device = d;
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, `Sonos ${d.Uuid} für ${d.Name} gefunden`);
+    }
+}
+exports.SonosService = SonosService;
+SonosService.ownDevices = {};

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramCommands = void 0;
+const enums_1 = require("../../enums");
+const telegram_service_1 = require("./telegram-service");
+const telegramMessageCalback_1 = require("./telegramMessageCalback");
+const devices_1 = require("../../devices");
+const room_service_1 = require("../room-service");
+const ShutterService_1 = require("../ShutterService");
+const command_1 = require("../../command");
+class TelegramCommands {
+    static initialize() {
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AlarmStop', /\/stop_alarm/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            room_service_1.RoomService.clearAllAlarms();
+            telegram_service_1.TelegramService.sendMessage([m.chat.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;
+            room_service_1.RoomService.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;
+            room_service_1.RoomService.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;
+            room_service_1.RoomService.endAlarmModes();
+            telegram_service_1.TelegramService.sendMessage([m.chat.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.chat.id], `Im Folgenden sind die letzten Bewegungen\n${room_service_1.RoomService.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.chat.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.chat.id], ShutterService_1.ShutterService.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('WindowCheck', /\/check_windows/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], devices_1.Griffe.getGriffPosition());
+            return true;
+        }, 'Returns the handle positions and warns about open windows.'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('BatteryCheck', /\/check_battery/, async (m) => {
+            if (m.from === undefined)
+                return Promise.resolve(false);
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], devices_1.Devices.getBatteryInfo());
+            return Promise.resolve(true);
+        }, 'Returns a list of all battery driven devices in ascending order.'));
+        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.chat.id], devices_1.HeatGroup.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.chat.id], devices_1.Heizgruppen.getProblems());
+            return true;
+        }, 'Zeigt Differenzen zwischen Heizungen und den jeweiligen Heizgruppen auf'));
+        telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AllRolloDown', /\/all_rollo_down/, async (m) => {
+            if (m.from === undefined)
+                return false;
+            room_service_1.RoomService.setAllShutterOfFloor(new command_1.FloorSetAllShuttersCommand(enums_1.CommandSource.Manual, 0, undefined, 'Telegram command AllRolloDown'));
+            telegram_service_1.TelegramService.sendMessage([m.chat.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.alLDevices) {
+                const d = devices_1.Devices.alLDevices[id];
+                if (d.deviceType === enums_1.DeviceType.ZigbeeAquaraVibra) {
+                    d.setSensitivity(2);
+                }
+            }
+            telegram_service_1.TelegramService.sendMessage([m.chat.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.alLDevices) {
+                const d = devices_1.Devices.alLDevices[id];
+                if (d.deviceType === enums_1.DeviceType.HmIpTaster) {
+                    response.push(d.getButtonAssignment());
+                }
+            }
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], response.join('\n'));
+            return true;
+        }, 'Retrieves the button assignments for all buttons in home'));
+        if (devices_1.Devices.energymanager !== undefined) {
+            telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('EnergyManager', /\/get_energy_values/, async (m) => {
+                var _a, _b;
+                if (m.from === undefined)
+                    return false;
+                const response = ['Current Energy Manager report:'];
+                response.push((_b = (_a = devices_1.Devices.energymanager) === null || _a === void 0 ? void 0 : _a.getReport()) !== null && _b !== void 0 ? _b : 'No Energy Manager found');
+                telegram_service_1.TelegramService.sendMessage([m.chat.id], response.join('\n'));
+                return true;
+            }, 'Retrieves the current energy manager values'));
+        }
+    }
+}
+exports.TelegramCommands = TelegramCommands;

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

@@ -0,0 +1,22 @@
+import TelegramBot from 'node-telegram-bot-api';
+import { Base64Image } from '../../models';
+import { iTelegramSettings } from '../../interfaces';
+import { TelegramMessageCallback } from './telegramMessageCalback';
+export declare class TelegramService {
+    private static subscribedIDs;
+    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 sendImage(message: string, image: Base64Image): void;
+    static sendMessageToSubscriber(message: string): void;
+    static sendMessage(ids: number[], message: string): void;
+    static checkAuthorized(msg: TelegramBot.Message): boolean;
+    static resetMessageCallbacks(): void;
+}