hoffmation-base 0.0.1

package/server/services/dbo/persist.ts

@@ -0,0 +1,125 @@
+import { Mongo } from 'meteor/mongo';
+import { ServerLogService } from '../log-service';
+import { LogLevel } from '../../../models/logLevel';
+import { TemperaturDataPoint } from '../../../models/persistence/temperaturDataPoint';
+import { CountToday } from '../../../models/persistence/todaysCount';
+import { HmIpHeizgruppe } from '../../devices/hmIPDevices/hmIpHeizgruppe';
+import { HmIPDevice } from '../../devices/hmIPDevices/hmIpDevice';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { BasicRoomInfo } from '../../../models/persistence/BasicRoomInfo';
+import { RoomDetailInfo } from '../../../models/persistence/RoomDetailInfo';
+import { iTemperaturDataPoint } from '/imports/api/heizung';
+import { DailyMovementCount } from '../../../models/persistence/DailyMovementCount';
+
+export const TemperatureHistoryCollection = new Mongo.Collection<TemperaturDataPoint>('TemperaturData');
+export const HeatGroupCollection = new Mongo.Collection<TemperaturDataPoint>('HeatGroupCollection');
+export const BasicRoomCollection = new Mongo.Collection<BasicRoomInfo>('BasicRooms');
+export const RoomDetailsCollection = new Mongo.Collection<RoomDetailInfo>('RoomDetailsCollection');
+export const CountTodayCollection = new Mongo.Collection<CountToday>('PresenceToday');
+export const DailyMovementCountTodayCollection = new Mongo.Collection<DailyMovementCount>('DailyMovementCount');
+export class Persist {
+  public static MeteorBound: (callback: any) => void;
+  public static addTemperaturDataPoint(hzGrp: HmIpHeizgruppe): void {
+    const dataPoint: iTemperaturDataPoint = new TemperaturDataPoint(
+      hzGrp.info.customName,
+      hzGrp.iTemperatur,
+      hzGrp.desiredTemperatur,
+      hzGrp.iLevel,
+      hzGrp.humidity,
+      new Date(),
+    );
+    ServerLogService.writeLog(LogLevel.Trace, `Persisting Temperatur Data for ${hzGrp.info.customName}`);
+    this.MeteorBound(() => {
+      TemperatureHistoryCollection.insert(dataPoint);
+    });
+
+    this.MeteorBound(() => {
+      HeatGroupCollection.update({ name: dataPoint.name }, dataPoint, { upsert: true });
+    });
+  }
+
+  public static addRoom(room: RoomBase): void {
+    ServerLogService.writeLog(LogLevel.Trace, `Persisting Room for ${room.roomName}`);
+    this.MeteorBound(() => {
+      BasicRoomCollection.update({ roomName: room.roomName }, new BasicRoomInfo(room.roomName, room.Settings.etage), {
+        upsert: true,
+      });
+    });
+    const detailed = new RoomDetailInfo(room.roomName, room.Settings.etage);
+    for (const h of room.HeatGroup.heaters) {
+      detailed.heaters.push(h.info.customName);
+    }
+    this.MeteorBound(() => {
+      RoomDetailsCollection.update({ roomName: room.roomName }, detailed, { upsert: true });
+    });
+  }
+
+  public static async getCount(device: HmIPDevice): Promise<CountToday> {
+    const result = new Promise<CountToday>((resolve) => {
+      this.MeteorBound(() => {
+        const options = {
+          limit: 1,
+        };
+        const databaseValue: CountToday[] = CountTodayCollection.find(
+          { deviceID: device.info.fullID },
+          options,
+        ).fetch();
+        if (databaseValue.length === 0) {
+          ServerLogService.writeLog(
+            LogLevel.Debug,
+            `Es gibt noch keinen persistierten Counter für ${device.info.fullName}`,
+          );
+          resolve(new CountToday(device.info.fullID, 0));
+        } else {
+          resolve(databaseValue[0]);
+        }
+      });
+    });
+
+    return result;
+  }
+
+  public static persistTodayCount(device: HmIPDevice, count: number, oldCount: number): void {
+    this.MeteorBound(() => {
+      const result = CountTodayCollection.update(
+        { deviceID: device.info.fullID },
+        new CountToday(device.info.fullID, count),
+        { upsert: true },
+      );
+      if (count === 0) {
+        const date = new Date();
+        date.setHours(-24, 0, 0, 0);
+        const result2 = DailyMovementCountTodayCollection.update(
+          { deviceID: device.info.fullID, date: date },
+          new DailyMovementCount(device.info.fullID, oldCount, device.info.room, date),
+          { upsert: true },
+        );
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Persisting Daily Movement Count for ${device.info.customName} to ${oldCount} resolved with "${result2}"`,
+        );
+      }
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Persisting PresenceToday Data for ${device.info.customName} to ${count} resolved with "${result}"`,
+      );
+    });
+  }
+
+  public static async readTemperaturDataPoint(
+    hzGrp: HmIpHeizgruppe,
+    limit: number = -1,
+  ): Promise<TemperaturDataPoint[]> {
+    const result = new Promise<TemperaturDataPoint[]>((resolve) => {
+      this.MeteorBound(() => {
+        const options = {
+          limit: limit > 0 ? limit : undefined,
+          sort: { date: -1 },
+        };
+        resolve(TemperatureHistoryCollection.find({ name: hzGrp.info.customName }, options).fetch());
+      });
+    });
+
+    return result;
+  }
+}

package/server/services/https-service.ts

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

package/server/services/log-service.ts

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

package/server/services/news-service.ts

@@ -0,0 +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 "/server/services/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

@@ -0,0 +1,23 @@
+import { iConfig } from '../config/iConfig';
+
+export class SettingsService {
+  public static settings: iConfig;
+
+  public static get TelegramActive(): boolean {
+    return this.settings.telegram !== undefined;
+  }
+
+  public static get Mp3Active(): boolean {
+    return this.settings.mp3Server !== undefined;
+  }
+
+  public static initialize(config: iConfig): void {
+    if (this.validateConfig(config)) {
+      this.settings = config;
+    }
+  }
+
+  private static validateConfig(config: iConfig): boolean {
+    return true;
+  }
+}

package/server/services/time-callback-service.ts

@@ -0,0 +1,223 @@
+import { TimeCallback, TimeCallbackType } from '../../models/timeCallback';
+import { getSunrise, getSunset } from 'sunrise-sunset-js';
+import { ServerLogService } from './log-service';
+import { LogLevel } from '../../models/logLevel';
+import { Devices } from '../devices/devices';
+import { Utils } from './utils/utils';
+import { SettingsService } from './settings-service';
+import { iTimePair } from '../config/iConfig';
+
+export enum TimeOfDay {
+  BeforeSunrise = 1,
+  Daylight = 2,
+  AfterSunset = 3,
+  Night = 4,
+}
+
+export class SunTimeOffsets {
+  public constructor(
+    public sunrise: number = 0,
+    public sunset: number = 0,
+    public minimumHours: number = 6,
+    public minimumMinutes: number = 24,
+    public maximumHours: number = 22,
+    public maximumMinutes: number = 30,
+  ) {}
+
+  public getNextMinimumSunrise(): Date {
+    const today: Date = new Date(new Date().setHours(this.minimumHours, this.minimumMinutes));
+    if (today > new Date()) {
+      return today;
+    }
+    return new Date(today.getTime() + 24 * 60 * 60 * 1000);
+  }
+
+  public getNextMaximumSunset(): Date {
+    const today = new Date(new Date().setHours(this.maximumHours, this.maximumMinutes));
+    if (today > new Date()) {
+      return today;
+    }
+    return new Date(today.getTime() + 24 * 60 * 60 * 1000);
+  }
+}
+
+export class TimeCallbackService {
+  private static _todaySunRise: Date;
+  private static _todaySunSet: Date;
+  private static _nextSunRise: Date;
+  private static _nextSunSet: Date;
+  private static _callbacks: TimeCallback[] = [];
+  private static _iCheck: NodeJS.Timeout;
+  private static _lastCheck: Date = new Date(0);
+
+  public static dayType(pOffset: SunTimeOffsets): TimeOfDay {
+    const now: Date = new Date();
+
+    const hours = now.getHours();
+    const minutes = now.getMinutes();
+
+    const nightEnd: iTimePair = SettingsService.settings.timeSettings.nightEnd;
+    const nightStart: iTimePair = SettingsService.settings.timeSettings.nightStart;
+
+    if (nightStart.hours < nightEnd.hours) {
+      if (
+        (hours < nightEnd.hours && hours > nightStart.hours) ||
+        (hours === nightEnd.hours && minutes < nightEnd.minutes) ||
+        (hours === nightStart.hours && minutes > nightStart.minutes)
+      ) {
+        return TimeOfDay.Night;
+      }
+    } else {
+      if (
+        hours > nightStart.hours ||
+        hours < nightEnd.hours ||
+        (hours === nightStart.hours && minutes >= nightStart.minutes) ||
+        (hours === nightEnd.hours && minutes <= nightEnd.minutes)
+      ) {
+        return TimeOfDay.Night;
+      }
+    }
+
+    let sunset: Date = new Date(TimeCallbackService._todaySunSet.getTime() + pOffset.sunset * 60 * 1000);
+    const maximumSunset: Date = pOffset.getNextMaximumSunset();
+    if (maximumSunset < sunset && maximumSunset.getDate() === sunset.getDate()) {
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Maximum Sunset vor nächstem Sunset: Sunset ${sunset.toLocaleString()}\t\t${maximumSunset.toLocaleString()}`,
+      );
+      sunset = maximumSunset;
+    }
+    if (now > sunset) {
+      return TimeOfDay.AfterSunset;
+    }
+    const minimumSunrise: Date = pOffset.getNextMinimumSunrise();
+    let sunrise: Date = new Date(TimeCallbackService._todaySunRise.getTime() + pOffset.sunset * 60 * 1000);
+    if (minimumSunrise > sunrise && minimumSunrise.getDate() === sunrise.getDate()) {
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Minimum Sunset nach aktuellem Sunrise: Sunset ${sunrise.toLocaleString()}\t\t${minimumSunrise.toLocaleString()}`,
+      );
+      sunrise = minimumSunrise;
+    }
+    if (now > sunrise) {
+      return TimeOfDay.Daylight;
+    }
+    return TimeOfDay.BeforeSunrise;
+  }
+
+  public static darkOutsideOrNight(dayType: TimeOfDay): boolean {
+    switch (dayType) {
+      case TimeOfDay.Night:
+      case TimeOfDay.BeforeSunrise:
+      case TimeOfDay.AfterSunset:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  public static get nextSunRise(): Date {
+    return TimeCallbackService._nextSunRise;
+  }
+
+  public static get nextSunSet(): Date {
+    return TimeCallbackService._nextSunSet;
+  }
+
+  public static init(): void {
+    const dailyRecalc: TimeCallback = new TimeCallback(
+      'Midnight Recalc',
+      TimeCallbackType.TimeOfDay,
+      () => {
+        TimeCallbackService.recalcSunTimes();
+        Devices.midnightReset();
+      },
+      0,
+      0,
+      0,
+    );
+
+    const daily3oClockRecalc: TimeCallback = new TimeCallback(
+      'Daily3oClockRecalc',
+      TimeCallbackType.TimeOfDay,
+      () => {
+        Devices.resetPraesenzCount();
+      },
+      0,
+      3,
+      0,
+    );
+
+    TimeCallbackService.recalcSunTimes();
+    TimeCallbackService.addCallback(dailyRecalc);
+    TimeCallbackService.addCallback(daily3oClockRecalc);
+    this._iCheck = Utils.guardedInterval(TimeCallbackService.performCheck, 60000);
+  }
+
+  public static addCallback(pCallback: TimeCallback): void {
+    TimeCallbackService._callbacks.push(pCallback);
+  }
+
+  public static performCheck(): void {
+    ServerLogService.writeLog(LogLevel.Trace, `Perform TimeCallBackCheck`);
+    const now: Date = new Date();
+    for (const tc of TimeCallbackService._callbacks) {
+      if (tc.nextToDo === undefined || tc.nextToDo < tc.lastDone) {
+        tc.recalcNextToDo(now);
+      }
+
+      if (tc.nextToDo === undefined) {
+        continue;
+      }
+
+      if (tc.nextToDo < now && tc.nextToDo > TimeCallbackService._lastCheck) {
+        tc.cFunction();
+        tc.lastDone = now;
+        tc.nextToDo = undefined;
+      }
+    }
+
+    if (TimeCallbackService._nextSunRise < now) {
+      const tomorow: Date = new Date(new Date().setHours(2, 0, 0, 0) + 24 * 60 * 60 * 1000);
+      TimeCallbackService.updateSunRise(tomorow);
+    }
+    if (TimeCallbackService._nextSunSet < now) {
+      const tomorow: Date = new Date(new Date().setHours(2, 0, 0, 0) + 24 * 60 * 60 * 1000);
+      TimeCallbackService.updateSunSet(tomorow);
+    }
+
+    TimeCallbackService._lastCheck = now;
+  }
+
+  public static recalcSunTimes(): void {
+    TimeCallbackService._todaySunRise = getSunrise(51.529556852253826, 7.097266042276687, new Date());
+
+    TimeCallbackService._todaySunSet = getSunset(51.529556852253826, 7.097266042276687, new Date());
+    TimeCallbackService.updateSunSet();
+    TimeCallbackService.updateSunRise();
+    ServerLogService.writeLog(
+      LogLevel.Info,
+      `Nächster Sonnenaufgang um ${TimeCallbackService.nextSunRise.toLocaleTimeString('de-DE')}
+Nächster Sonnenuntergang um ${TimeCallbackService._nextSunSet.toLocaleTimeString('de-DE')}`,
+    );
+  }
+
+  public static removeCallback(pCallback: TimeCallback): void {
+    for (let i: number = 0; i < TimeCallbackService._callbacks.length; i++) {
+      const cb: TimeCallback = TimeCallbackService._callbacks[i];
+      if (cb.name !== pCallback.name) {
+        continue;
+      }
+      TimeCallbackService._callbacks.splice(i, 1);
+      return;
+    }
+  }
+
+  public static updateSunRise(pDay: Date = new Date()): void {
+    TimeCallbackService._nextSunRise = getSunrise(51.529556852253826, 7.097266042276687, pDay);
+  }
+
+  public static updateSunSet(pDay: Date = new Date()): void {
+    TimeCallbackService._nextSunSet = getSunset(51.529556852253826, 7.097266042276687, pDay);
+  }
+}

package/server/services/utils/ringstorage.ts

@@ -0,0 +1,24 @@
+export class ringStorage {
+  private storage: string[] = [];
+  private pointer: number = 0;
+
+  public constructor(private maxSize: number = 10) {}
+
+  public add(text: string): void {
+    this.pointer = (this.pointer + 1) % this.maxSize;
+    this.storage[this.pointer] = text;
+  }
+
+  public readAmount(amount: number): string[] {
+    const result: string[] = [];
+    amount = Math.max(amount, this.maxSize);
+    let pos = this.pointer;
+    while (amount > 0) {
+      result.push(this.storage[pos]);
+      // Um negative Modulo zu umgehen.
+      pos = (((pos - 1) % this.maxSize) + this.maxSize) % this.maxSize;
+      amount--;
+    }
+    return result;
+  }
+}

package/server/services/utils/utils.ts

@@ -0,0 +1,52 @@
+import { ServerLogService } from '../log-service';
+import { LogLevel } from '../../../models/logLevel';
+
+export class Utils {
+  public static guardedFunction(func: (...args: unknown[]) => void, thisContext: unknown | undefined): void {
+    try {
+      if (thisContext) {
+        func.bind(thisContext)();
+      } else {
+        func();
+      }
+    } catch (e) {
+      ServerLogService.writeLog(LogLevel.Error, `Guarded Function failed: ${e.message}\n Stack: ${e.stack}`);
+    }
+  }
+
+  public static nowMS(): number {
+    return new Date().getTime();
+  }
+
+  public static guardedNewThread(func: (...args: unknown[]) => void, thisContext?: unknown | undefined): void {
+    Utils.guardedTimeout(func, 1, thisContext);
+  }
+
+  public static guardedTimeout(
+    func: (...args: unknown[]) => void,
+    time: number,
+    thisContext?: unknown | undefined,
+  ): NodeJS.Timeout {
+    return setTimeout(() => {
+      Utils.guardedFunction(func, thisContext);
+    }, time);
+  }
+
+  public static guardedInterval(
+    func: (...args: unknown[]) => void,
+    time: number,
+    thisContext?: unknown | undefined,
+    fireImmediate: boolean = false,
+  ): NodeJS.Timeout {
+    if (fireImmediate) {
+      Utils.guardedFunction(func, thisContext);
+    }
+    return setInterval(() => {
+      Utils.guardedFunction(func, thisContext);
+    }, time);
+  }
+  public static nowString(): string {
+    const d: Date = new Date();
+    return `${d.toLocaleTimeString('de-DE')}.${d.getMilliseconds()}`;
+  }
+}

package/server/services/weather/weather-alert.ts

@@ -0,0 +1,7 @@
+export interface WeatherAlert {
+  sender_name: string;
+  event: string;
+  start: number;
+  end: number;
+  description: string;
+}