hoffmation-base 0.0.1

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

@@ -0,0 +1,215 @@
+import TelegramBot from 'node-telegram-bot-api';
+import { Devices } from '../../devices/devices';
+import { TelegramService } from './telegram-service';
+import { TelegramMessageCallback } from './telegramMessageCalback';
+import { Griffe } from '../../devices/Griffe';
+import { Heizgruppen } from '../../devices/Heizgruppen';
+import { Rolladen } from '../../devices/Rollos';
+import { ZigbeeAquaraVibra } from '../../devices/zigbee/zigbeeAquaraVibra';
+import { ZigbeeDeviceType } from '../../devices/zigbee/zigbeeDeviceType';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { SonosService } from '../Sonos/sonos-service';
+
+export class TelegramCommands {
+  private static devices: Devices;
+
+  public static initialize(pDevices: Devices): void {
+    TelegramCommands.devices = pDevices;
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'AlarmStop',
+        /\/stop_alarm/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          RoomBase.clearAllAlarms();
+          TelegramService.sendMessage(
+            [m.from.id],
+            'Alle ausgelösten Wasser-/Rauchmelder und Eindringlingsalarme wurden gestoppt.',
+          );
+          return true;
+        },
+        'Eine Möglichkeit bei Fehlalarm den Alarm abzuschalten',
+      ),
+    );
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'AwayModeStart',
+        /\/away_mode_start/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          RoomBase.startAwayMode();
+          TelegramService.inform('Der Abwesenheitsmodus ist initiiert');
+          return true;
+        },
+        'Eine Möglichkeit die Alarmanlage scharfzuschalten',
+      ),
+    );
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'NightAlarmMode',
+        /\/nightalarm_mode_start/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          RoomBase.startNightAlarmMode();
+          TelegramService.inform('Der Nachtmodus ist initiiert');
+          return true;
+        },
+        'Alarmanlage für die Nacht scharf schalten',
+      ),
+    );
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'AlarmModesEnd',
+        /\/alarm_modes_end/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          RoomBase.endAlarmModes();
+          TelegramService.sendMessage([m.from.id], 'Der Abwesenheitsmodus ist deaktiviert.');
+          return true;
+        },
+        'Alarmanlage nach Abwesenheit/Nacht entschärfen',
+      ),
+    );
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'LastMovements',
+        /\/check_movement/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          TelegramService.sendMessage(
+            [m.from.id],
+            `Im Folgenden sind die letzten Bewegungen\n${RoomBase.getLastMovements()}`,
+          );
+          return true;
+        },
+        'Gibt die letzten Bewegungen inkl. ihrer Uhrzeit aus.',
+      ),
+    );
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'TelegramTest',
+        /\/test/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          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',
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'RolloObenCheck',
+        /\/check_rollo/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          TelegramService.sendMessage([m.from.id], Rolladen.getRolladenPosition());
+          return true;
+        },
+        'Gibt die Positionen der Rollos aus, warnt über offene Rollos und nennt die nächsten Fahrten',
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'FensterCheck',
+        /\/check_fenster/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          TelegramService.sendMessage([m.from.id], Griffe.getGriffPosition());
+          return true;
+        },
+        'Gibt die Positionen der Fenstergriffe aus und warnt somit über offene Fenster',
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'HeizungCheck',
+        /\/check_temperatur/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          TelegramService.sendMessage([m.from.id], Heizgruppen.getInfo());
+          return true;
+        },
+        'Gibt die Namen und aktuellen Werte sämtlicher Heizgruppen aus (aktuelle Temperatur, Soll Temperatur, Ventilstellung).',
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'HeizungError',
+        /\/temperatur_error/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          TelegramService.sendMessage([m.from.id], Heizgruppen.getProblems());
+          return true;
+        },
+        'Zeigt Differenzen zwischen Heizungen und den jeweiligen Heizgruppen auf',
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'HeizungCheckOne',
+        /\/check_1_temperatur.*/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          TelegramService.sendMessage([m.from.id], await Heizgruppen.getSpecificInfo(m.text));
+          return true;
+        },
+        `Gibt den Verlauf der in \\"\\" übergebenen Heizgruppe aus.`,
+        /\/check_1_temperatur/,
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'AllRolloDown',
+        /\/all_rollo_down/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          RoomBase.setAllRolloOfFloor(-1, 0);
+          TelegramService.sendMessage([m.from.id], `Es werden alle Rollos heruntergefahren`);
+          return true;
+        },
+        `Fährt alle rollos runter`,
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'VibrationSensitivity',
+        /\/set_vibration_sensitivity/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          for (const id in Devices.Zigbee) {
+            const d = Devices.Zigbee[id];
+            if (d.deviceType === ZigbeeDeviceType.ZigbeeAquaraVibra) {
+              (d as ZigbeeAquaraVibra).setSensitivity(2);
+            }
+          }
+          TelegramService.sendMessage([m.from.id], 'Abgeschlossen');
+          return true;
+        },
+        `Setzt alle Vibrationsensoren auf High`,
+      ),
+    );
+
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'SonosTest',
+        /\/perform_sonos_test/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return false;
+          SonosService.speakTestMessageOnEachDevice();
+          TelegramService.sendMessage([m.from.id], 'Testnachricht gesprochen --> Führe weiteren Test durch');
+          SonosService.checkAll();
+          return true;
+        },
+        `Spiele eine kurze Nachricht auf allen Sonos Geräten um diese zu identifizieren`,
+      ),
+    );
+  }
+}

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

@@ -0,0 +1,171 @@
+import TelegramBot from 'node-telegram-bot-api';
+import { ServerLogService } from '../log-service';
+import { TelegramMessageCallback } from './telegramMessageCalback';
+import { LogLevel } from '../../../models/logLevel';
+import { iTelegramSettings } from '../../config/iConfig';
+export class TelegramService {
+  public static subscribedIDs: number[];
+
+  private static token: string;
+  private static active: boolean = false;
+  private static bot: TelegramBot;
+  private static allowedIDs: number[];
+  private static settings: iTelegramSettings | undefined = undefined;
+  private static restartTimeout: NodeJS.Timeout | undefined = undefined;
+
+  private static callbacks: { [name: string]: TelegramMessageCallback } = {};
+
+  public static addMessageCallback(pCallback: TelegramMessageCallback, reset: boolean = false): void {
+    if (!reset) {
+      TelegramService.callbacks[pCallback.name] = pCallback;
+    }
+    TelegramService.bot.onText(pCallback.identifier, (msg) => {
+      if (!TelegramService.checkAuthorized(msg)) {
+        return;
+      }
+      pCallback.callback(msg);
+    });
+    ServerLogService.writeLog(
+      LogLevel.Debug,
+      `Telegram Callback mit Namen ${pCallback.name} für Nachrichten mit "${pCallback.identifier}" hinzugefügt`,
+    );
+  }
+
+  public static initialize(settings?: iTelegramSettings): void {
+    if (!settings && this.settings === undefined) {
+      this.active = false;
+      return;
+    }
+
+    if (settings) {
+      this.settings = settings;
+      ServerLogService.telegramLevel = settings.logLevel;
+      this.token = settings.telegramToken;
+      this.allowedIDs = settings.allowedIDs;
+      this.subscribedIDs = settings.subscribedIDs;
+    }
+
+    this.active = true;
+    this.bot = new TelegramBot(this.token, { polling: true, webHook: false });
+    this.bot.on('polling_error', (e) => {
+      /*
+      if (!this.reinitiliazeWithTimeout()) {
+        return;
+      }
+       */
+      ServerLogService.writeLog(LogLevel.Debug, `Telegram Polling Error: ${e.message}`);
+      ServerLogService.writeLog(LogLevel.Trace, `Telegram Polling Error stack: ${e.stack}`);
+    });
+    TelegramService.addMessageCallback(
+      new TelegramMessageCallback(
+        'helpCommand',
+        /\/help/,
+        async (m: TelegramBot.Message): Promise<boolean> => {
+          if (m.from === undefined) return true;
+          const message: string[] = [];
+          message.push('Im folgenden ist eine Liste sämtlicher Kommandos:\n');
+          for (const cName in TelegramService.callbacks) {
+            const telegramCb: TelegramMessageCallback = TelegramService.callbacks[cName];
+            message.push(
+              `${telegramCb.identifier.toString().replace(/\//g, '').replace(/\\/g, '')} - ${telegramCb.helpMessage}`,
+            );
+          }
+          TelegramService.sendMessage([m.from?.id], message.join('\n'));
+          return true;
+        },
+        `Gibt eine Liste mit sämtlichen Kommandos aus`,
+      ),
+    );
+    TelegramService.inform(`(Re-)Initialisierung abgeschlossen`);
+  }
+
+  public static publishCommands(): void {
+    const commands: TelegramBot.BotCommand[] = [];
+    for (const cName in TelegramService.callbacks) {
+      const telegramCb: TelegramMessageCallback = TelegramService.callbacks[cName];
+      const commandIdentifier: string = (
+        telegramCb.identifierForCommandList !== undefined ? telegramCb.identifierForCommandList : telegramCb.identifier
+      )
+        .toString()
+        .replace(/\//g, '')
+        .replace(/\\/g, '');
+      commands.push({ command: commandIdentifier, description: telegramCb.helpMessage });
+    }
+
+    ServerLogService.writeLog(LogLevel.Debug, `New Telegram Commands: "${JSON.stringify(commands)}"`);
+    TelegramService.bot.setMyCommands(commands);
+  }
+
+  public static inform(message: string): void {
+    this.sendMessage(this.subscribedIDs, message);
+  }
+
+  public static sendMessage(ids: number[], message: string): void {
+    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;
+    }
+
+    for (const id of ids) {
+      this.bot.sendMessage(id, message).catch((r) => {
+        ServerLogService.writeLog(LogLevel.Warn, `Send Telegram Message to ${id} failed: ${r}`);
+      });
+    }
+  }
+
+  public static checkAuthorized(msg: TelegramBot.Message): boolean {
+    if (msg.from !== undefined && this.allowedIDs.includes(msg.from?.id)) {
+      ServerLogService.writeLog(LogLevel.Debug, `Authorisierte Telegram Message erhalten: ${JSON.stringify(msg)}`);
+      return true;
+    }
+
+    ServerLogService.writeLog(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;
+  }
+  */
+
+  public static resetMessageCallbacks(): void {
+    TelegramService.bot.clearTextListeners();
+    for (const name in TelegramService.callbacks) {
+      this.addMessageCallback(TelegramService.callbacks[name]);
+    }
+  }
+}

package/server/services/Telegram/telegramMessageCalback.ts

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

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

@@ -0,0 +1,224 @@
+import { async, VEvent } from 'node-ical';
+import { ServerLogService } from '../log-service';
+import { OwnSonosDevice, SonosService } from '../Sonos/sonos-service';
+import { TelegramService } from '../Telegram/telegram-service';
+import { TimeCallbackService } from '../time-callback-service';
+import { LogLevel } from '../../../models/logLevel';
+import { TimeCallback, TimeCallbackType } from '../../../models/timeCallback';
+import { iMuellSettings } from '../../config/iConfig';
+import { Utils } from '../utils/utils';
+
+export class MuellTonne {
+  public static oneDay: number = 1000 * 60 * 60 * 24;
+  public nextDate: Date | undefined = undefined;
+  public dates: Date[] = [];
+
+  public constructor(public name: string, public ownSonosDevice?: OwnSonosDevice) {
+  }
+
+  public sortDates(): void {
+    this.dates = this.dates.sort((a, b) => a.getTime() - b.getTime());
+    this.removePassedDates();
+    ServerLogService.writeLog(
+      LogLevel.Info,
+      `Die "${this.name}" ist das nächste mal am ${this.nextDate.toLocaleDateString('de-DE')} zu leeren`,
+    );
+  }
+
+  public removePassedDates(): void {
+    const todayMidnight: number = 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];
+  }
+
+  public check(): void {
+    this.removePassedDates();
+    if (this.nextDate === undefined) {
+      ServerLogService.writeLog(LogLevel.Alert, `Die Mülltonne mit dem Namen ${this.name} hat keine nächste Abholung!`);
+      return;
+    }
+    const todayMidnight: number = new Date().setHours(0, 0, 0, 0);
+    const tomorowMidnight: number = todayMidnight + MuellTonne.oneDay;
+    const tomorowAfterMidnight: number = tomorowMidnight + MuellTonne.oneDay;
+    const nextTimestamp: number = this.nextDate.getTime();
+
+    const daysTilNextEvent: number = (nextTimestamp - todayMidnight) / MuellTonne.oneDay;
+    ServerLogService.writeLog(
+      LogLevel.Info,
+      `Die Mülltonne mit dem Namen ${this.name} wird in ${daysTilNextEvent} Tagen das nächste Mal abgeholt.`,
+    );
+
+    if (nextTimestamp >= tomorowAfterMidnight) {
+      ServerLogService.writeLog(
+        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!`;
+      TelegramService.inform(message);
+
+      if (this.ownSonosDevice) {
+        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!`;
+        TelegramService.inform(message);
+        if (this.ownSonosDevice) {
+          SonosService.speakOnDevice(message, this.ownSonosDevice, 30);
+        }
+      } else {
+        const message = `Die Mülltonne mit dem Namen ${this.name} wird heute abgeholt!`;
+        TelegramService.inform(message);
+        if (this.ownSonosDevice) {
+          SonosService.speakOnDevice(message, this.ownSonosDevice, 30);
+        }
+      }
+      return;
+    }
+  }
+}
+
+export class MuellService {
+  public static alleTonnen: Array<{ name: string; date: Date }> = [];
+  public static blaueTonne: MuellTonne;
+  public static graueTonne: MuellTonne;
+  public static gelbeTonne: MuellTonne;
+  public static brauneTonne: MuellTonne;
+  public static updateTimeCallback: TimeCallback;
+  public static checkTimeCallback: TimeCallback;
+  private static lastCheck: Date = new Date(0);
+  private static _calendarURL: string;
+  private static _active: boolean = false;
+
+  public static months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+  public static intialize(config: iMuellSettings): void {
+    this._active = true;
+    this._calendarURL = config.calendarURL;
+    this.updateTimeCallback = new TimeCallback(
+      'MuelltonnenServiceUpdater',
+      TimeCallbackType.TimeOfDay,
+      () => {
+        this.updateCalendar(false);
+      },
+      0,
+      2,
+      0,
+    );
+    TimeCallbackService.addCallback(this.updateTimeCallback);
+
+    this.checkTimeCallback = new TimeCallback(
+      'MuelltonnenServiceChecker',
+      TimeCallbackType.TimeOfDay,
+      () => {
+        this.checkAll();
+      },
+      0,
+      18,
+      0,
+    );
+    TimeCallbackService.addCallback(this.checkTimeCallback);
+
+    this.updateCalendar();
+  }
+
+  public static updateCalendar(checkAfterwards: boolean = true): void {
+    ServerLogService.writeLog(LogLevel.Debug, `Muell Service wird nun initialisiert`);
+    async.fromURL(this._calendarURL).then((data) => {
+      this.gelbeTonne = new MuellTonne('Gelbe Tonne');
+      this.graueTonne = new MuellTonne('Graue Tonne');
+      this.blaueTonne = new MuellTonne('Blaue Tonne');
+      this.brauneTonne = new MuellTonne('Braune Tonne');
+      this.alleTonnen = [];
+      const todayMidnight: number = 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] as VEvent;
+        ServerLogService.writeLog(
+          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:
+            ServerLogService.writeLog(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();
+      }
+    });
+  }
+
+  public static checkAll(pRetries: number = 10): void {
+    if (!this._active) {
+      return;
+    }
+
+    const now: Date = new Date();
+    if (now.getTime() - this.lastCheck.getTime() < 60000 && now.getDate() === this.lastCheck.getDate()) {
+      ServerLogService.writeLog(LogLevel.Trace, `MüllService.checkAll: Skipped weil wir gerade erst geprüft hatten.`);
+      return;
+    }
+
+    if (this.gelbeTonne === undefined) {
+      if (pRetries > 0) {
+        ServerLogService.writeLog(LogLevel.Warn, `Der Müllservice ist noch nicht bereit --> warten`);
+        Utils.guardedTimeout(() => {
+          MuellService.checkAll(pRetries - 1);
+        }, 1000);
+      } else {
+        ServerLogService.writeLog(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();
+  }
+}