hoffmation-base 0.1.14 → 0.1.18

package/server/ioBroker/ioBroker.main.ts

@@ -1,99 +0,0 @@
-import { LogLevel } from '../../models/logLevel';
-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 { RoomBase } from '../../models/rooms/RoomBase';
-import { Utils } from '../services/utils/utils';
-import { SettingsService } from '../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

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

package/server/ioBroker/socketIOConnectOptions.ts

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

package/server/ioBroker/socketIOLogging.ts

@@ -1,29 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/OwnSonosDevices.ts

@@ -1,9 +0,0 @@
-import { OwnSonosDevice } from './sonos-service';
-
-export class OwnSonosDevices {
-  public static ownDevices: { [name: string]: OwnSonosDevice } = {};
-
-  public static addDevice(device: OwnSonosDevice) {
-    this.ownDevices[device.name] = device;
-  }
-}

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

@@ -1,75 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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,194 +0,0 @@
-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`);
-  }
-}