hoffmation-base 0.1.1 → 0.1.5

package/server/services/Sonos/polly-service.ts

@@ -1,100 +1,100 @@
-import AWS from 'aws-sdk';
-import { ServerLogService } from '../log-service';
-import { LogLevel } from '../../../models/logLevel';
-import * as fs from 'fs';
-import getMP3Duration from 'get-mp3-duration';
-import crypto from 'crypto';
-import { iPollySettings } from '../../config/iConfig';
-
-export class PollyService {
-  private static _mp3Path: string;
-  public static active: boolean = false;
-  public static polly: AWS.Polly;
-  public static voice: string;
-
-  public static initialize(config: iPollySettings): void {
-    this.active = true;
-    this._mp3Path = config.mp3Path;
-    this.polly = new AWS.Polly({
-      region: config.region,
-      signatureVersion: config.signatureVersion,
-      credentials: {
-        accessKeyId: config.accessKeyId,
-        secretAccessKey: config.secretAccessKey,
-      },
-    });
-    this.voice = config.voiceID;
-  }
-
-  public static getDuration(name: string): number {
-    const fPath: string = this._mp3Path + name + '.mp3';
-    try {
-      if (fs.existsSync(fPath)) {
-        const duration: number = getMP3Duration(fs.readFileSync(fPath));
-        return duration;
-      }
-    } catch (err) {
-      console.error(err);
-    }
-    return 1800000;
-  }
-
-  public static preloadTTS(text: string): void {
-    if (!this.active) {
-      return;
-    }
-    this.tts(text, (link, duration) => {
-      if (duration <= 0) {
-        ServerLogService.writeLog(LogLevel.Error, `Retrieving tts for "${text}" failed as duration is 0 or lower`);
-      } else if (!link) {
-        ServerLogService.writeLog(LogLevel.Error, `Retrieving tts for "${text}" failed as link is empty`);
-      }
-    });
-  }
-
-  public static tts(text: string, cb: (fileLink: string, duration: number) => void): void {
-    const hash: string = `${this.voice}_${crypto.createHash('md5').update(text).digest('hex')}`;
-    const fPath: string = `${this._mp3Path}${hash}.mp3`;
-    try {
-      if (fs.existsSync(fPath)) {
-        const duration: number = getMP3Duration(fs.readFileSync(fPath));
-        cb(hash, duration);
-        return;
-      }
-    } catch (err) {
-      console.error(err);
-    }
-
-    ServerLogService.writeLog(LogLevel.Debug, `Für die Nachricht "${text}" fehlt die TTS --> bei AWS anfragen`);
-    const params: AWS.Polly.SynthesizeSpeechInput = {
-      Text: text,
-      OutputFormat: 'mp3',
-      VoiceId: this.voice,
-    };
-    this.polly.synthesizeSpeech(params, (err, data) => {
-      if (err) {
-        ServerLogService.writeLog(LogLevel.Error, `AWS Polly Error: ${err}`);
-        return;
-      }
-
-      if (!data || data.AudioStream === undefined) {
-        ServerLogService.writeLog(LogLevel.Error, `AWS Polly didn't send any data`);
-        return;
-      }
-
-      ServerLogService.writeLog(LogLevel.Debug, `AWS Antwort für (${hash}) erhalten Text: "${text}"`);
-
-      fs.writeFile(fPath, data.AudioStream as string | NodeJS.ArrayBufferView, (err) => {
-        const duration: number = getMP3Duration(data.AudioStream);
-        if (err) {
-          ServerLogService.writeLog(LogLevel.Error, `AWS Polly: Saving failed`);
-          return;
-        }
-        ServerLogService.writeLog(LogLevel.Trace, `AWS Polly: Saving sucessfully`);
-
-        cb(hash, duration);
-        return;
-      });
-    });
-  }
-}
+import AWS from 'aws-sdk';
+import { ServerLogService } from '../log-service';
+import { LogLevel } from '../../../models/logLevel';
+import * as fs from 'fs';
+import getMP3Duration from 'get-mp3-duration';
+import crypto from 'crypto';
+import { iPollySettings } from '../../config/iConfig';
+
+export class PollyService {
+  private static _mp3Path: string;
+  public static active: boolean = false;
+  public static polly: AWS.Polly;
+  public static voice: string;
+
+  public static initialize(config: iPollySettings): void {
+    this.active = true;
+    this._mp3Path = config.mp3Path;
+    this.polly = new AWS.Polly({
+      region: config.region,
+      signatureVersion: config.signatureVersion,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+      },
+    });
+    this.voice = config.voiceID;
+  }
+
+  public static getDuration(name: string): number {
+    const fPath: string = this._mp3Path + name + '.mp3';
+    try {
+      if (fs.existsSync(fPath)) {
+        const duration: number = getMP3Duration(fs.readFileSync(fPath));
+        return duration;
+      }
+    } catch (err) {
+      console.error(err);
+    }
+    return 1800000;
+  }
+
+  public static preloadTTS(text: string): void {
+    if (!this.active) {
+      return;
+    }
+    this.tts(text, (link, duration) => {
+      if (duration <= 0) {
+        ServerLogService.writeLog(LogLevel.Error, `Retrieving tts for "${text}" failed as duration is 0 or lower`);
+      } else if (!link) {
+        ServerLogService.writeLog(LogLevel.Error, `Retrieving tts for "${text}" failed as link is empty`);
+      }
+    });
+  }
+
+  public static tts(text: string, cb: (fileLink: string, duration: number) => void): void {
+    const hash: string = `${this.voice}_${crypto.createHash('md5').update(text).digest('hex')}`;
+    const fPath: string = `${this._mp3Path}${hash}.mp3`;
+    try {
+      if (fs.existsSync(fPath)) {
+        const duration: number = getMP3Duration(fs.readFileSync(fPath));
+        cb(hash, duration);
+        return;
+      }
+    } catch (err) {
+      console.error(err);
+    }
+
+    ServerLogService.writeLog(LogLevel.Debug, `Für die Nachricht "${text}" fehlt die TTS --> bei AWS anfragen`);
+    const params: AWS.Polly.SynthesizeSpeechInput = {
+      Text: text,
+      OutputFormat: 'mp3',
+      VoiceId: this.voice,
+    };
+    this.polly.synthesizeSpeech(params, (err, data) => {
+      if (err) {
+        ServerLogService.writeLog(LogLevel.Error, `AWS Polly Error: ${err}`);
+        return;
+      }
+
+      if (!data || data.AudioStream === undefined) {
+        ServerLogService.writeLog(LogLevel.Error, `AWS Polly didn't send any data`);
+        return;
+      }
+
+      ServerLogService.writeLog(LogLevel.Debug, `AWS Antwort für (${hash}) erhalten Text: "${text}"`);
+
+      fs.writeFile(fPath, data.AudioStream as string | NodeJS.ArrayBufferView, (err) => {
+        const duration: number = getMP3Duration(data.AudioStream);
+        if (err) {
+          ServerLogService.writeLog(LogLevel.Error, `AWS Polly: Saving failed`);
+          return;
+        }
+        ServerLogService.writeLog(LogLevel.Trace, `AWS Polly: Saving sucessfully`);
+
+        cb(hash, duration);
+        return;
+      });
+    });
+  }
+}

package/server/services/Sonos/sonos-service.ts

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