hoffmation-base 0.0.1

package/server/ioBroker/ioBroker.main.ts

@@ -0,0 +1,99 @@
+import { Devices } from '../devices/devices';
+import { DeviceUpdater } from '../devices/deviceUpdater';
+import { IDeviceUpdater } from '../devices/iDeviceUpdater';
+import { ServerLogService } from '../services/log-service';
+import { TimeCallbackService } from '../services/time-callback-service';
+import { IOBrokerConnection } from './connection';
+import { ConnectionCallbacks } from '/models/connectionCallbacks';
+import { LogLevel } from '/models/logLevel';
+import { RoomBase } from '/models/rooms/RoomBase';
+import { Utils } from '/server/services/utils/utils';
+import { SettingsService } from "/server/services/settings-service";
+
+export class ioBrokerMain {
+  private static roomConstructors: { [roomName: string]: { new (): RoomBase } } = {};
+  private servConn: IOBrokerConnection;
+  private deviceUpdater: IDeviceUpdater;
+  private states: Record<string, ioBroker.State> = {};
+  private connectionCallbacks: ConnectionCallbacks;
+
+  public static addRoomConstructor(roomName: string, constr: { new (): RoomBase }): void {
+    if (ioBrokerMain.roomConstructors[roomName] !== undefined) {
+      ServerLogService.writeLog(LogLevel.Error, `Konstruktor für Raum mit Namen "${roomName}" bereits hinzugefügt`);
+      return;
+    }
+    ioBrokerMain.roomConstructors[roomName] = constr;
+  }
+
+  public constructor(pDeviceUpdater: DeviceUpdater) {
+    this.deviceUpdater = pDeviceUpdater;
+    this.connectionCallbacks = new ConnectionCallbacks();
+    this.initConnCallbacks();
+
+    this.servConn = new IOBrokerConnection(
+      {
+        name: '', // optional - default 'vis.0'
+        connLink: SettingsService.settings.ioBrokerUrl, // optional URL of the socket.io adapter
+        socketSession: '', // optional - used by authentication
+      },
+      this.connectionCallbacks,
+    );
+
+    Devices.addIoConnection(this.servConn);
+    ioBrokerMain.initRooms();
+  }
+
+  private static initRooms(): void {
+    for (const key in ioBrokerMain.roomConstructors) {
+      new ioBrokerMain.roomConstructors[key]();
+    }
+  }
+
+  private initConnCallbacks(): void {
+    this.connectionCallbacks.onObjectChange = (pId: string, pObj: ioBroker.Object) => {
+      Utils.guardedNewThread(() => {
+        this.deviceUpdater.updateObject(pId, pObj);
+      }, this);
+    };
+
+    this.connectionCallbacks.onConnChange = (isConnected: boolean) => {
+      if (!isConnected) {
+        console.log('disconnected');
+        return;
+      }
+
+      console.log('connected');
+      this.servConn.getStates(null, (err, _states) => {
+        if (_states === undefined) {
+          return;
+        }
+        ServerLogService.writeLog(LogLevel.Debug, `Im initialen GetStates Callback`);
+
+        let count = 0;
+        for (const id in _states) {
+          this.deviceUpdater.updateState(id, _states[id], true);
+          count++;
+        }
+        console.log('Received ' + count + ' states.');
+        this.states = _states;
+        TimeCallbackService.performCheck();
+        TimeCallbackService.performCheck();
+      });
+    };
+    this.connectionCallbacks.onRefresh = () => {
+      //
+    };
+
+    this.connectionCallbacks.onUpdate = (id: string, state: ioBroker.State) => {
+      Utils.guardedNewThread(() => {
+        // console.log('NEW VALUE of ' + id + ': ' + JSON.stringify(state));
+        this.states[id] = state;
+        this.deviceUpdater.updateState(id, state);
+      }, this);
+    };
+
+    this.connectionCallbacks.onError = (err: any) => {
+      console.log(`Cannot execute ${err.command} for ${err.arg}, because of insufficient permissions`);
+    };
+  }
+}

package/server/ioBroker/socketIOAuthInfo.ts

@@ -0,0 +1,5 @@
+export class SocketIOAuthInfo {
+  public user: any;
+  public hash: any;
+  public salt: any;
+}

package/server/ioBroker/socketIOConnectOptions.ts

@@ -0,0 +1,6 @@
+export class SocketIOConnectOpts {
+  public name?: string;
+  public connLink?: any;
+  public socketSession?: any;
+  public socketForceWebSockets?: boolean;
+}

package/server/ioBroker/socketIOLogging.ts

@@ -0,0 +1,29 @@
+export class SocketIoLogging {
+  public static LogLevel = 5;
+  public static writeLog(pLevel: SocketIoLogLevel, pMessage: string): void {
+    if (pLevel > SocketIoLogging.LogLevel) {
+      return;
+    }
+
+    switch (pLevel) {
+      case SocketIoLogLevel.Error:
+        console.error(pMessage);
+        break;
+      case SocketIoLogLevel.Error:
+        console.warn(pMessage);
+        break;
+      default:
+        console.log(pMessage);
+        break;
+    }
+  }
+}
+
+export enum SocketIoLogLevel {
+  Error = 1,
+  Warn = 2,
+  Info = 3,
+  Debug = 4,
+  Trace = 5,
+  DeepTrace = 6,
+}

package/server/ioBroker/socketIOVisCommand.ts

@@ -0,0 +1,11 @@
+export class SocketIOVisCommand {
+  public command: string;
+  public data: string;
+  public instance: string;
+
+  constructor(pObject: any) {
+    this.command = pObject.command;
+    this.data = pObject.data;
+    this.instance = pObject.instance;
+  }
+}

package/server/services/HTTPSOptions.ts

@@ -0,0 +1,14 @@
+import { ServerLogService } from './log-service';
+import { LogLevel } from '../../models/logLevel';
+
+export class HTTPSOptions {
+  constructor(
+    public hostname: string,
+    public path: string,
+    public headers: { [id: string]: string } = {},
+    public method: string = 'POST',
+    public port: number = 443,
+  ) {
+    ServerLogService.writeLog(LogLevel.Debug, `${method} Request at '${hostname}' for '${path}'`);
+  }
+}

package/server/services/Sonos/mp3-server.ts

@@ -0,0 +1,75 @@
+import * as http from 'http';
+import * as url from 'url';
+import * as fs from 'fs';
+import { ServerLogService } from '../log-service';
+import { LogLevel } from '../../../models/logLevel';
+import { iMp3Settings } from '../../config/iConfig';
+
+export class MP3Server {
+  public static active: boolean = false;
+  public count: number = 0;
+  private mp3Path: string = '';
+
+  public constructor(settings: iMp3Settings) {
+    if (!settings) {
+      return;
+    }
+
+    this.mp3Path = settings.path;
+    MP3Server.active = true;
+    http
+      .createServer((req, response) => {
+        if (req.url === undefined) {
+          response.writeHead(500);
+          response.end('ungültige Anfrage', 'utf-8');
+          return;
+        }
+        const q = url.parse(req.url, true).query;
+
+        const fName = q.fname;
+
+        if (!fName || fName.indexOf('.') >= 0) {
+          response.writeHead(500);
+          response.end('ungültiger Dateiname', 'utf-8');
+          return;
+        }
+
+        ServerLogService.writeLog(LogLevel.DeepTrace, `Anfrage für ${fName}`);
+        const fPath: string = this.mp3Path + fName + '.mp3';
+        try {
+          if (!fs.existsSync(fPath)) {
+            ServerLogService.writeLog(LogLevel.Error, `Die angefragte Datei existiert nicht ${fName}`);
+            return;
+          }
+        } catch (err) {
+          console.error(err);
+        }
+
+        const filestream = fs.createReadStream(fPath);
+        response.writeHead(200, { 'Content-Type': 'audio/mpeg3' });
+        filestream.pipe(response, { end: true });
+
+        /*
+      fs.readFile(fPath, (error, data) => {
+          if (error) {
+            if(error.code == 'ENOENT'){
+                fs.readFile('./404.html', (err, cont) => {
+                    response.writeHead(200, { 'Content-Type': "audio/mpeg3" });
+                    response.end(cont, 'utf-8');
+                });
+            }
+            else {
+                response.writeHead(500);
+                response.end('Sorry, check with the site admin for error: '+error.code+' ..\n');
+            }
+        }
+        else {
+            response.writeHead(200, { 'Content-Type': "audio/mpeg3" });
+            response.end(data, 'utf-8');
+        }
+      })
+      */
+      })
+      .listen(8081);
+  }
+}

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

@@ -0,0 +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;
+      });
+    });
+  }
+}

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

@@ -0,0 +1,199 @@
+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 '/server/services/utils/utils';
+import { TelegramService } from '/server/services/Telegram/telegram-service';
+import { TimeCallback, TimeCallbackType } from '/models/timeCallback';
+import { TimeCallbackService } from '/server/services/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
+    ServerLogService.writeLog(LogLevel.Debug, `Sonos ${d.Uuid} für ${d.Name} gefunden`);
+  }
+}