hoffmation-base 0.1.1 → 0.1.5

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

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

@@ -1,24 +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;
-  }
-}
+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

@@ -1,52 +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()}`;
-  }
-}
+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

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

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

@@ -1,26 +1,26 @@
-import { WeatherItem } from './weather-item';
-
-export interface WeatherCurrent {
-  /**
-   * Zeit der Anfrage
-   * @type {number}
-   * @memberof WeatherCurrent
-   */
-  dt: number;
-  sunrise: number;
-  sunset: number;
-  temp: number;
-  feels_like: number;
-  pressure: number;
-  humidity: number;
-  dew_point: number;
-  uvi: number;
-  clouds: number;
-  rain?: number;
-  snow?: number;
-  visibility: number;
-  wind_speed: number;
-  wind_deg: number;
-  wind_gust: number;
-  weather: WeatherItem[];
-}
+import { WeatherItem } from './weather-item';
+
+export interface WeatherCurrent {
+  /**
+   * Zeit der Anfrage
+   * @type {number}
+   * @memberof WeatherCurrent
+   */
+  dt: number;
+  sunrise: number;
+  sunset: number;
+  temp: number;
+  feels_like: number;
+  pressure: number;
+  humidity: number;
+  dew_point: number;
+  uvi: number;
+  clouds: number;
+  rain?: number;
+  snow?: number;
+  visibility: number;
+  wind_speed: number;
+  wind_deg: number;
+  wind_gust: number;
+  weather: WeatherItem[];
+}