hoffmation-base 0.1.1 → 0.1.5

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

@@ -1,171 +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]);
-    }
-  }
-}
+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

@@ -1,11 +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,
-  ) {}
-}
+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/muell-tonne.ts

@@ -1,83 +1,82 @@
-import { OwnSonosDevice, SonosService } from "/server/config/private/server/services/Sonos/sonos-service";
-import { ServerLogService } from "/server/config/private/server/services/log-service";
-import { LogLevel } from "/server/config/private/models/logLevel";
-import { TelegramService } from "/server/config/private/server/services/Telegram/telegram-service";
-
-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;
-    }
-  }
-}
+import { OwnSonosDevice, SonosService } from '../Sonos/sonos-service';
+import { ServerLogService } from '../log-service';
+import { LogLevel } from '../../../models/logLevel';
+import { TelegramService } from '../Telegram/telegram-service';
+
+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;
+    }
+  }
+}