hoffmation-base 0.1.1 → 0.1.5

package/server/services/https-service.ts

@@ -1,71 +1,71 @@
-import { HTTPSOptions } from './HTTPSOptions';
-import { ServerLogService } from './log-service';
-import { LogLevel } from '../../models/logLevel';
-import * as fs from 'fs';
-import HTTPS from 'https';
-import { Utils } from './utils/utils';
-
-export class HTTPSService {
-  private static defaultCallback(data: string, statuscode: number): void {
-    ServerLogService.writeLog(LogLevel.DeepTrace, `Response statusCode:"${statuscode}"\nData:"${data}"`);
-  }
-
-  public static request(
-    options: HTTPSOptions,
-    postData: string = '',
-    retryOnError: number = 5,
-    responseCallback: (data: string, statuscode: number) => void = HTTPSService.defaultCallback,
-  ): void {
-    const responseData: string[] = [];
-    const req = HTTPS.request(options, (res: any) => {
-      res.on('data', (data: Buffer) => {
-        responseData.push(data.toString());
-      });
-      res.on('end', () => {
-        responseCallback(responseData.join(''), res.statusCode);
-      });
-    });
-    req.on('error', (e: any) => {
-      if (retryOnError > 0) {
-        ServerLogService.writeLog(LogLevel.DeepTrace, `HTTPS request failed --> ${retryOnError} retries left`);
-        Utils.guardedTimeout(() => {
-          HTTPSService.request(options, postData, retryOnError - 1, responseCallback);
-        }, 100);
-      } else {
-        ServerLogService.writeLog(LogLevel.Error, `HTTPS request failed after retries`);
-      }
-    });
-    if (postData !== '') {
-      req.write(postData);
-    }
-    req.end();
-  }
-
-  public static async downloadFile(url: string, filePath: string): Promise<boolean> {
-    return new Promise((resolve, reject) => {
-      const file = fs.createWriteStream(filePath);
-      let fileInfo = null;
-
-      const request = HTTPS.get(url, (response: any) => {
-        if (response.statusCode !== 200) {
-          reject(new Error(`Failed to get '${url}' (${response.statusCode})`));
-          return;
-        }
-
-        fileInfo = {
-          mime: response.headers['content-type'],
-          size: parseInt(response.headers['content-length'], 10),
-        };
-
-        response.pipe(file);
-      });
-
-      // The destination stream is ended by the time it's called
-      file.on('finish', () => resolve(true));
-
-      request.on('error', (err: any) => {
-        fs.unlink(filePath, () => resolve(false));
-      });
-    });
-  }
-}
+import { HTTPSOptions } from './HTTPSOptions';
+import { ServerLogService } from './log-service';
+import { LogLevel } from '../../models/logLevel';
+import * as fs from 'fs';
+import HTTPS from 'https';
+import { Utils } from './utils/utils';
+
+export class HTTPSService {
+  private static defaultCallback(data: string, statuscode: number): void {
+    ServerLogService.writeLog(LogLevel.DeepTrace, `Response statusCode:"${statuscode}"\nData:"${data}"`);
+  }
+
+  public static request(
+    options: HTTPSOptions,
+    postData: string = '',
+    retryOnError: number = 5,
+    responseCallback: (data: string, statuscode: number) => void = HTTPSService.defaultCallback,
+  ): void {
+    const responseData: string[] = [];
+    const req = HTTPS.request(options, (res: any) => {
+      res.on('data', (data: Buffer) => {
+        responseData.push(data.toString());
+      });
+      res.on('end', () => {
+        responseCallback(responseData.join(''), res.statusCode);
+      });
+    });
+    req.on('error', (e: any) => {
+      if (retryOnError > 0) {
+        ServerLogService.writeLog(LogLevel.DeepTrace, `HTTPS request failed --> ${retryOnError} retries left`);
+        Utils.guardedTimeout(() => {
+          HTTPSService.request(options, postData, retryOnError - 1, responseCallback);
+        }, 100);
+      } else {
+        ServerLogService.writeLog(LogLevel.Error, `HTTPS request failed after retries`);
+      }
+    });
+    if (postData !== '') {
+      req.write(postData);
+    }
+    req.end();
+  }
+
+  public static async downloadFile(url: string, filePath: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      const file = fs.createWriteStream(filePath);
+      let fileInfo = null;
+
+      const request = HTTPS.get(url, (response: any) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to get '${url}' (${response.statusCode})`));
+          return;
+        }
+
+        fileInfo = {
+          mime: response.headers['content-type'],
+          size: parseInt(response.headers['content-length'], 10),
+        };
+
+        response.pipe(file);
+      });
+
+      // The destination stream is ended by the time it's called
+      file.on('finish', () => resolve(true));
+
+      request.on('error', (err: any) => {
+        fs.unlink(filePath, () => resolve(false));
+      });
+    });
+  }
+}

package/server/services/log-service.ts

@@ -1,69 +1,69 @@
-import { HmIpDeviceType } from '../devices/hmIPDevices/hmIpDeviceType';
-import { ZigbeeDeviceType } from '../devices/zigbee/zigbeeDeviceType';
-import { TelegramService } from './Telegram/telegram-service';
-import { LogLevel } from '../../models/logLevel';
-
-export class ServerLogService {
-  public static logLevel: number = 4;
-  public static telegramLevel: number = -1; // Controlled from within Config File
-  public static writeLog(pLevel: LogLevel, pMessage: string): void {
-    if (pLevel > ServerLogService.logLevel) {
-      return;
-    }
-
-    console.log(pMessage);
-
-    if (pLevel <= ServerLogService.telegramLevel) {
-      const title: string = LogLevel[pLevel];
-      TelegramService.sendMessage(TelegramService.subscribedIDs, `${title}: ${pMessage}`);
-    }
-  }
-
-  public static addedDeviceToRoom(
-    pRoomName: string,
-    pDeviceType: HmIpDeviceType,
-    pRoomIndex: number,
-    forceDebug: boolean = false,
-  ): void {
-    const logLevel = forceDebug ? LogLevel.Debug : LogLevel.Trace;
-    ServerLogService.writeLog(
-      logLevel,
-      `${HmIpDeviceType[pDeviceType]} (Raumindex: ${pRoomIndex}) zum Raum "${pRoomName}" hinzugefügt"`,
-    );
-  }
-
-  public static missingRoomHandling(pRoomName: string, pDeviceType: HmIpDeviceType): void {
-    ServerLogService.writeLog(
-      LogLevel.Warn,
-      `Raum "${pRoomName}" hat keine Definition für den Typ "${HmIpDeviceType[pDeviceType]}"`,
-    );
-  }
-
-  public static missingRoomIndexHandling(pRoomName: string, pIndex: number, pDeviceType: HmIpDeviceType): void {
-    ServerLogService.writeLog(
-      LogLevel.Warn,
-      `Raum "${pRoomName}" hat keine Definition für den Typ "${HmIpDeviceType[pDeviceType]} mit Index ${pIndex}"`,
-    );
-  }
-
-  public static addedZigbeeDeviceToRoom(pRoomName: string, pDeviceType: ZigbeeDeviceType, pRoomIndex: number): void {
-    ServerLogService.writeLog(
-      LogLevel.Trace,
-      `${ZigbeeDeviceType[pDeviceType]} (Raumindex: ${pRoomIndex}) zum Raum "${pRoomName}" hinzugefügt"`,
-    );
-  }
-
-  public static missingZigbeeRoomHandling(pRoomName: string, pDeviceType: ZigbeeDeviceType): void {
-    ServerLogService.writeLog(
-      LogLevel.Warn,
-      `Raum "${pRoomName}" hat keine Definition für den Zigbee Typ "${ZigbeeDeviceType[pDeviceType]}"`,
-    );
-  }
-
-  public static missingZigbeeRoomIndexHandling(pRoomName: string, pIndex: number, pDeviceType: ZigbeeDeviceType): void {
-    ServerLogService.writeLog(
-      LogLevel.Warn,
-      `Raum "${pRoomName}" hat keine Definition für den Typ "${ZigbeeDeviceType[pDeviceType]} mit Index ${pIndex}"`,
-    );
-  }
-}
+import { HmIpDeviceType } from '../devices/hmIPDevices/hmIpDeviceType';
+import { ZigbeeDeviceType } from '../devices/zigbee/zigbeeDeviceType';
+import { TelegramService } from './Telegram/telegram-service';
+import { LogLevel } from '../../models/logLevel';
+
+export class ServerLogService {
+  public static logLevel: number = 4;
+  public static telegramLevel: number = -1; // Controlled from within Config File
+  public static writeLog(pLevel: LogLevel, pMessage: string): void {
+    if (pLevel > ServerLogService.logLevel) {
+      return;
+    }
+
+    console.log(pMessage);
+
+    if (pLevel <= ServerLogService.telegramLevel) {
+      const title: string = LogLevel[pLevel];
+      TelegramService.sendMessage(TelegramService.subscribedIDs, `${title}: ${pMessage}`);
+    }
+  }
+
+  public static addedDeviceToRoom(
+    pRoomName: string,
+    pDeviceType: HmIpDeviceType,
+    pRoomIndex: number,
+    forceDebug: boolean = false,
+  ): void {
+    const logLevel = forceDebug ? LogLevel.Debug : LogLevel.Trace;
+    ServerLogService.writeLog(
+      logLevel,
+      `${HmIpDeviceType[pDeviceType]} (Raumindex: ${pRoomIndex}) zum Raum "${pRoomName}" hinzugefügt"`,
+    );
+  }
+
+  public static missingRoomHandling(pRoomName: string, pDeviceType: HmIpDeviceType): void {
+    ServerLogService.writeLog(
+      LogLevel.Warn,
+      `Raum "${pRoomName}" hat keine Definition für den Typ "${HmIpDeviceType[pDeviceType]}"`,
+    );
+  }
+
+  public static missingRoomIndexHandling(pRoomName: string, pIndex: number, pDeviceType: HmIpDeviceType): void {
+    ServerLogService.writeLog(
+      LogLevel.Warn,
+      `Raum "${pRoomName}" hat keine Definition für den Typ "${HmIpDeviceType[pDeviceType]} mit Index ${pIndex}"`,
+    );
+  }
+
+  public static addedZigbeeDeviceToRoom(pRoomName: string, pDeviceType: ZigbeeDeviceType, pRoomIndex: number): void {
+    ServerLogService.writeLog(
+      LogLevel.Trace,
+      `${ZigbeeDeviceType[pDeviceType]} (Raumindex: ${pRoomIndex}) zum Raum "${pRoomName}" hinzugefügt"`,
+    );
+  }
+
+  public static missingZigbeeRoomHandling(pRoomName: string, pDeviceType: ZigbeeDeviceType): void {
+    ServerLogService.writeLog(
+      LogLevel.Warn,
+      `Raum "${pRoomName}" hat keine Definition für den Zigbee Typ "${ZigbeeDeviceType[pDeviceType]}"`,
+    );
+  }
+
+  public static missingZigbeeRoomIndexHandling(pRoomName: string, pIndex: number, pDeviceType: ZigbeeDeviceType): void {
+    ServerLogService.writeLog(
+      LogLevel.Warn,
+      `Raum "${pRoomName}" hat keine Definition für den Typ "${ZigbeeDeviceType[pDeviceType]} mit Index ${pIndex}"`,
+    );
+  }
+}

package/server/services/news-service.ts

@@ -1,81 +1,81 @@
-import { HTTPSService } from './https-service';
-import { HTTPSOptions } from './HTTPSOptions';
-import { ServerLogService } from './log-service';
-import { LogLevel } from '../../models/logLevel';
-import * as fs from 'fs';
-import { OwnSonosDevice, SonosService } from './Sonos/sonos-service';
-import { PollyService } from './Sonos/polly-service';
-import { Utils } from './utils/utils';
-import { SettingsService } from './settings-service';
-
-export class NewsService {
-  public static oneDay: number = 1000 * 60 * 60 * 24;
-  public static lastNewsName: string;
-  private static hourlyInterval: NodeJS.Timeout;
-
-  public static initialize(): void {
-    NewsService.hourlyInterval = Utils.guardedInterval(NewsService.getLastNews, 3600000);
-    NewsService.getLastNews();
-  }
-
-  public static getLastNews(): void {
-    HTTPSService.request(
-      new HTTPSOptions('www1.wdr.de', '/mediathek/audio/wdr-aktuell-news/index.html', {}, 'GET', 443),
-      '',
-      5,
-      (response: string) => {
-        try {
-          const cutAfterDownload: string = response.split(`" title="Audio Download">`)[0];
-          const cutsPriorDownload: string[] = cutAfterDownload.split(`<a class="button download fsk0" href="`);
-          const target: string = 'https:' + cutsPriorDownload[cutsPriorDownload.length - 1];
-          const splits: string[] = target.split('/');
-          const fileName: string = splits[splits.length - 1];
-          const filePath = `${SettingsService.settings.mp3Server?.path}${fileName}`;
-          ServerLogService.writeLog(LogLevel.Debug, `NewsService: Die aktuelle News ist "${target}"`);
-          if (fs.existsSync(filePath)) {
-            NewsService.lastNewsName = fileName.split('.mp3')[0];
-            ServerLogService.writeLog(LogLevel.Debug, `Wir haben bereits die neuste WDR Nachrichten heruntergeladen.`);
-            return;
-          }
-          HTTPSService.downloadFile(target, `//HOMESERVER/Users/Public/Documents/ttsMP3/${fileName}`).then(
-            (success: boolean) => {
-              if (!success) {
-                ServerLogService.writeLog(LogLevel.Debug, `Fehler beim Herunterladen der Nachrichten von WDR`);
-                return;
-              }
-
-              NewsService.lastNewsName = fileName.split('.mp3')[0];
-            },
-          );
-        } catch (e) {
-          ServerLogService.writeLog(LogLevel.Debug, `Fehler beim Parsen der WDR Antwort Error: ${e}`);
-          return;
-        }
-      },
-    );
-  }
-
-  public static playLastNews(ownSonosDevice: OwnSonosDevice, volume: number = 30, retries: number = 5): void {
-    if (!NewsService.lastNewsName) {
-      if (retries > 0) {
-        ServerLogService.writeLog(
-          LogLevel.Warn,
-          `Der NewsService ist noch nicht bereit --> warten, verbleibende Neuversuche ${retries - 1}`,
-        );
-        Utils.guardedTimeout(() => {
-          NewsService.playLastNews(ownSonosDevice, volume, retries - 1);
-        }, 1000);
-      } else {
-        ServerLogService.writeLog(LogLevel.Error, `Der NewsService ist trotz Warten nicht bereit --> Abbruch`);
-      }
-      return;
-    }
-
-    SonosService.playOnDevice(
-      ownSonosDevice,
-      NewsService.lastNewsName,
-      PollyService.getDuration(NewsService.lastNewsName),
-      volume,
-    );
-  }
-}
+import { HTTPSService } from './https-service';
+import { HTTPSOptions } from './HTTPSOptions';
+import { ServerLogService } from './log-service';
+import { LogLevel } from '../../models/logLevel';
+import * as fs from 'fs';
+import { OwnSonosDevice, SonosService } from './Sonos/sonos-service';
+import { PollyService } from './Sonos/polly-service';
+import { Utils } from './utils/utils';
+import { SettingsService } from './settings-service';
+
+export class NewsService {
+  public static oneDay: number = 1000 * 60 * 60 * 24;
+  public static lastNewsName: string;
+  private static hourlyInterval: NodeJS.Timeout;
+
+  public static initialize(): void {
+    NewsService.hourlyInterval = Utils.guardedInterval(NewsService.getLastNews, 3600000);
+    NewsService.getLastNews();
+  }
+
+  public static getLastNews(): void {
+    HTTPSService.request(
+      new HTTPSOptions('www1.wdr.de', '/mediathek/audio/wdr-aktuell-news/index.html', {}, 'GET', 443),
+      '',
+      5,
+      (response: string) => {
+        try {
+          const cutAfterDownload: string = response.split(`" title="Audio Download">`)[0];
+          const cutsPriorDownload: string[] = cutAfterDownload.split(`<a class="button download fsk0" href="`);
+          const target: string = 'https:' + cutsPriorDownload[cutsPriorDownload.length - 1];
+          const splits: string[] = target.split('/');
+          const fileName: string = splits[splits.length - 1];
+          const filePath = `${SettingsService.settings.mp3Server?.path}${fileName}`;
+          ServerLogService.writeLog(LogLevel.Debug, `NewsService: Die aktuelle News ist "${target}"`);
+          if (fs.existsSync(filePath)) {
+            NewsService.lastNewsName = fileName.split('.mp3')[0];
+            ServerLogService.writeLog(LogLevel.Debug, `Wir haben bereits die neuste WDR Nachrichten heruntergeladen.`);
+            return;
+          }
+          HTTPSService.downloadFile(target, `//HOMESERVER/Users/Public/Documents/ttsMP3/${fileName}`).then(
+            (success: boolean) => {
+              if (!success) {
+                ServerLogService.writeLog(LogLevel.Debug, `Fehler beim Herunterladen der Nachrichten von WDR`);
+                return;
+              }
+
+              NewsService.lastNewsName = fileName.split('.mp3')[0];
+            },
+          );
+        } catch (e) {
+          ServerLogService.writeLog(LogLevel.Debug, `Fehler beim Parsen der WDR Antwort Error: ${e}`);
+          return;
+        }
+      },
+    );
+  }
+
+  public static playLastNews(ownSonosDevice: OwnSonosDevice, volume: number = 30, retries: number = 5): void {
+    if (!NewsService.lastNewsName) {
+      if (retries > 0) {
+        ServerLogService.writeLog(
+          LogLevel.Warn,
+          `Der NewsService ist noch nicht bereit --> warten, verbleibende Neuversuche ${retries - 1}`,
+        );
+        Utils.guardedTimeout(() => {
+          NewsService.playLastNews(ownSonosDevice, volume, retries - 1);
+        }, 1000);
+      } else {
+        ServerLogService.writeLog(LogLevel.Error, `Der NewsService ist trotz Warten nicht bereit --> Abbruch`);
+      }
+      return;
+    }
+
+    SonosService.playOnDevice(
+      ownSonosDevice,
+      NewsService.lastNewsName,
+      PollyService.getDuration(NewsService.lastNewsName),
+      volume,
+    );
+  }
+}

package/server/services/settings-service.ts

@@ -1,15 +1,15 @@
-// @ts-ignore
-import config from '/server/config/private/mainConfig.json';
-import { iConfig } from '../config/iConfig';
-
-export class SettingsService {
-  public static settings: iConfig = config as iConfig;
-
-  public static get TelegramActive(): boolean {
-    return this.settings.telegram !== undefined;
-  }
-
-  public static get Mp3Active(): boolean {
-    return this.settings.mp3Server !== undefined;
-  }
-}
+// @ts-ignore
+import config from '/server/config/private/mainConfig.json';
+import { iConfig } from '../config/iConfig';
+
+export class SettingsService {
+  public static settings: iConfig = config as iConfig;
+
+  public static get TelegramActive(): boolean {
+    return this.settings.telegram !== undefined;
+  }
+
+  public static get Mp3Active(): boolean {
+    return this.settings.mp3Server !== undefined;
+  }
+}