hoffmation-base 0.0.1

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

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

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

@@ -0,0 +1,22 @@
+import { WeatherFeelsLike } from './weather-feelsLike';
+import { WeatherItem } from './weather-item';
+import { WeatherTemp } from './weather-temp';
+
+export interface WeatherDaily {
+  dt: number;
+  sunrise: number;
+  sunset: number;
+  pressure: number;
+  humidity: number;
+  dew_point: number;
+  wind_speed: number;
+  wind_deg: number;
+  clouds: number;
+  pop: number;
+  rain?: number;
+  snow?: number;
+  uvi: number;
+  temp: WeatherTemp;
+  feels_like: WeatherFeelsLike;
+  weather: WeatherItem[];
+}

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

@@ -0,0 +1,6 @@
+export interface WeatherFeelsLike {
+  day: number;
+  night: number;
+  eve: number;
+  morn: number;
+}

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

@@ -0,0 +1,17 @@
+import { WeatherItem } from './weather-item';
+
+export interface WeatherHourly {
+  dt: number;
+  temp: number;
+  feels_like: number;
+  pressure: number;
+  humidity: number;
+  dew_point: number;
+  uvi: number;
+  clouds: number;
+  visibility: number;
+  wind_speed: number;
+  wind_deg: number;
+  weather: WeatherItem[];
+  pop: number;
+}

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

@@ -0,0 +1,6 @@
+export interface WeatherItem {
+  id: number;
+  main: string;
+  description: string;
+  icon: string;
+}

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

@@ -0,0 +1,4 @@
+export interface WeatherMinutes {
+  dt: number;
+  precipitation: number;
+}

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

@@ -0,0 +1,277 @@
+import { HTTPSService } from '../https-service';
+import { HTTPSOptions } from '../HTTPSOptions';
+import { ServerLogService } from '../log-service';
+import { OwnSonosDevice, SonosService } from '../Sonos/sonos-service';
+import { WeatherAlert } from './weather-alert';
+import { WeatherCurrent } from './weather-current';
+import { WeatherDaily } from './weather-daily';
+import { WeatherHourly } from './weather-hourly';
+import { WeatherMinutes } from './weather-minutes';
+import { LogLevel } from '../../../models/logLevel';
+import { iWeatherSettings } from '../../config/iConfig';
+import { Utils } from '../utils/utils';
+
+export interface WeatherResponse {
+  lat: number;
+  lon: number;
+  timezone: string;
+  timezone_offset: number;
+  current: WeatherCurrent;
+  minutely: WeatherMinutes[];
+  hourly: WeatherHourly[];
+  daily: WeatherDaily[];
+  alerts?: WeatherAlert[];
+}
+
+export class WeatherService {
+  public static active: boolean = false;
+  public static oneDay: number = 1000 * 60 * 60 * 24;
+  public static lastResponse: WeatherResponse;
+  private static _refreshInterval: NodeJS.Timeout;
+  private static latitude: string;
+  private static longitude: string;
+  private static appID: string;
+
+  public static initialize(config: iWeatherSettings): void {
+    this.active = true;
+    this.longitude = config.longitude;
+    this.latitude = config.lattitude;
+    this.appID = config.appid;
+
+    this._refreshInterval = Utils.guardedInterval(WeatherService.getWeatherData, 10 * 60 * 1000, WeatherService, true);
+  }
+
+  public static playWeatherInfo(
+    sonosDevice: OwnSonosDevice,
+    volume: number = 30,
+    short: boolean = false,
+    retries = 5,
+  ): void {
+    const wData: WeatherResponse = WeatherService.lastResponse;
+    if (wData === undefined) {
+      if (retries > 0) {
+        ServerLogService.writeLog(
+          LogLevel.Warn,
+          `WeatherService.playWeatherInfo(): Der Wetterbericht ist noch nicht bereit --> warten`,
+        );
+        setTimeout(() => {
+          WeatherService.playWeatherInfo(sonosDevice, volume, short, retries - 1);
+        }, 1000);
+      } else {
+        ServerLogService.writeLog(
+          LogLevel.Error,
+          `WeatherService.playWeatherInfo(): Der Wetterbericht ist vorhanden --> Abbruch`,
+        );
+      }
+      return;
+    }
+
+    SonosService.speakOnDevice(short ? `Kurze Wetterinfo:` : `HoffMation Wetter-Bericht:`, sonosDevice, volume, false);
+    SonosService.speakOnDevice(
+      `Wetterbeschreibung für heute:  ${wData.daily[0].weather[0].description}`,
+      sonosDevice,
+      volume,
+      false,
+    );
+    SonosService.speakOnDevice(`Aktuell sind es ${Math.round(wData.current.temp)} Grad.`, sonosDevice, volume, false);
+    if (!short) {
+      SonosService.speakOnDevice(
+        `Heute sollen es im Durchschnitt ${Math.round(wData.daily[0].temp.day)} Grad sein.`,
+        sonosDevice,
+        volume,
+        false,
+      );
+      SonosService.speakOnDevice(
+        `Die Höchsttemperatur liegt heute bei ${Math.round(wData.daily[0].temp.max)} Grad.`,
+        sonosDevice,
+        volume,
+        false,
+      );
+      SonosService.speakOnDevice(
+        `Die Tiefsttemperatur soll heute ${Math.round(wData.daily[0].temp.min)} Grad betragen.`,
+        sonosDevice,
+        volume,
+        false,
+      );
+      if (wData.daily[0].rain !== undefined) {
+        SonosService.speakOnDevice(
+          `Es sollen heute etwa ${Math.round(wData.daily[0].rain)} Millimeter Regen fallen.`,
+          sonosDevice,
+          volume,
+          false,
+        );
+      }
+    }
+    if (wData.daily[0].snow !== undefined && wData.daily[0].snow > 0) {
+      SonosService.speakOnDevice(
+        `Heute wird es Schneien! Es werden etwa ${Math.round(wData.daily[0].snow)} Millimeter Schnee erwartet.`,
+        sonosDevice,
+        volume,
+        false,
+      );
+    }
+
+    const { minutes, precipitation } = WeatherService.getRainNextMinutes();
+    const ratio: number = minutes <= 0 ? 0 : (precipitation / minutes) * 60;
+    let message = `In der nächsten Zeit `;
+    switch (true) {
+      case ratio > 12:
+        message += `wird es kräftig regnen`;
+        break;
+      case ratio > 4:
+        message += `wird es ordentlich regnen`;
+        break;
+      case ratio > 1:
+        message += `wird es regnen`;
+        break;
+      case ratio > 0.5:
+        message += `wird es mäßig regnen`;
+        break;
+      case ratio > 0.1:
+        message += `wird es nieseln regnen`;
+        break;
+      default:
+        message += `bleibt es trocken.`;
+        break;
+    }
+    SonosService.speakOnDevice(message, sonosDevice, volume, false);
+    !short &&
+      precipitation > 0 &&
+      SonosService.speakOnDevice(
+        `Es werden etwa ${precipitation} Millimeter Niederschlag in den nächsten ${minutes} Minuten fallen`,
+        sonosDevice,
+        volume,
+        false,
+      );
+
+    const alerts: WeatherAlert[] = WeatherService.getActiveAlerts();
+    if (alerts.length > 0) {
+      const alertMessage: string[] = [`Achtung, vorliegende Wetterwarnungen:`];
+      alerts.forEach((element) => {
+        alertMessage.push(
+          `${element.event} von ${new Date(element.start * 1000).toLocaleString('de-DE')} bis ${new Date(
+            element.end * 1000,
+          ).toLocaleString('de-DE')}`,
+        );
+        // } bis ${new Date(element.end * 1000).toLocaleString("de-DE")}; Beschreibung: ${element.description} Herausgeber: ${element.sender_name}`)
+      });
+      SonosService.speakOnDevice(alertMessage.join('\n'), sonosDevice, volume, false);
+    } else if (!short) {
+      SonosService.speakOnDevice(`Für heute liegt keine Unwetterwarnungen vor`, sonosDevice, volume, false);
+    }
+  }
+
+  private static getRainNextMinutes(): { minutes: number; precipitation: number } {
+    const minutes: WeatherMinutes[] = WeatherService.lastResponse.minutely;
+    let minutesUsed = 0;
+    let precipitation = 0;
+    if (minutes !== undefined) {
+      const now: number = new Date().getTime();
+      minutes.forEach((element) => {
+        if (element.dt * 1000 > now) {
+          minutesUsed++;
+          precipitation += element.precipitation;
+        }
+      });
+    }
+
+    return { minutes: minutesUsed, precipitation: precipitation };
+  }
+
+  private static getActiveAlerts(): WeatherAlert[] {
+    const result: WeatherAlert[] = [];
+    if (WeatherService.lastResponse.alerts === undefined || WeatherService.lastResponse.alerts.length === 0) {
+      return result;
+    }
+    const now: number = new Date().getTime();
+    const todayMidnight: number = new Date().setHours(0, 0, 0, 0);
+    const tomorowMidnight: number = todayMidnight + WeatherService.oneDay;
+
+    WeatherService.lastResponse.alerts.forEach((element) => {
+      const timestampStart: number = element.start * 1000;
+      if (
+        (timestampStart > todayMidnight && timestampStart < tomorowMidnight) ||
+        (timestampStart < now && element.end * 1000 > now)
+      ) {
+        result.push(element);
+      }
+    });
+    return result;
+  }
+
+  private static getWeatherData(): void {
+    HTTPSService.request(
+      new HTTPSOptions(
+        'api.openweathermap.org',
+        `/data/2.5/onecall?lat=${WeatherService.latitude}&lon=${WeatherService.longitude}&appid=${WeatherService.appID}&units=metric&lang=de`,
+        {},
+        'GET',
+        443,
+      ),
+      '',
+      5,
+      (response: string) => {
+        ServerLogService.writeLog(LogLevel.Debug, `WeatherAPi Response erhalten`);
+        ServerLogService.writeLog(LogLevel.DeepTrace, `WeatherAPi Response: ${response}`);
+        Utils.guardedFunction(() => {
+          WeatherService.lastResponse = JSON.parse(response);
+          WeatherService.processHourlyWeather();
+        }, this);
+      },
+    );
+  }
+
+  public static processHourlyWeather(): void {
+    ServerLogService.writeLog(
+      LogLevel.Info,
+      `Es sind gerade ${this.lastResponse.current.temp} Grad (gefühlt ${this.lastResponse.current.feels_like}).`,
+    );
+    if (this.lastResponse.alerts !== undefined && this.lastResponse.alerts.length > 0) {
+      const message: string[] = [`Es gibt folgende Wetterwarnungen:`];
+      this.lastResponse.alerts.forEach((element) => {
+        message.push(
+          `${element.event} von ${new Date(element.start * 1000)} bis ${new Date(element.end * 1000)}; Beschreibung: ${
+            element.description
+          } Herausgeber: ${element.sender_name}`,
+        );
+      });
+      ServerLogService.writeLog(LogLevel.Info, message.join('\n'));
+    }
+  }
+
+  public static getCurrentTemp(): number {
+    const wData: WeatherResponse = WeatherService.lastResponse;
+    if (wData === undefined || wData.current === undefined) {
+      ServerLogService.writeLog(LogLevel.Info, `WeatherService.isOutsideWarmer(): There are no data yet`);
+      return -99;
+    }
+    return wData.current.temp;
+  }
+
+  public static isOutsideWarmer(currentTemperatur: number): boolean {
+    const wData: WeatherResponse = WeatherService.lastResponse;
+    if (wData === undefined || wData.current === undefined) {
+      ServerLogService.writeLog(LogLevel.Info, `WeatherService.isOutsideWarmer(): There are no data yet`);
+      return false;
+    }
+    ServerLogService.writeLog(
+      LogLevel.Info,
+      `isOutsideWarmer(${currentTemperatur}) --> Aktuelle Temperatur: ${wData.current.temp}`,
+    );
+    return currentTemperatur < wData.current.temp;
+  }
+
+  public static weatherRolloPosition(normalPos: number, desiredTemperatur: number, currentTemperatur: number): number {
+    let result: number = normalPos;
+    if (currentTemperatur > desiredTemperatur && this.isOutsideWarmer(currentTemperatur) && normalPos > 30) {
+      // Draußen ist wärmer also runter
+      result = 30;
+    }
+
+    ServerLogService.writeLog(
+      LogLevel.Info,
+      `weatherRolloPosition(${normalPos}, ${desiredTemperatur}, ${currentTemperatur}) --> Target: ${result}`,
+    );
+    return result;
+  }
+}

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

@@ -0,0 +1,8 @@
+export interface WeatherTemp {
+  day: number;
+  min: number;
+  max: number;
+  night: number;
+  eve: number;
+  morn: number;
+}

package/tsconfig.json

@@ -0,0 +1,59 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "target": "es2018",
+    "module": "esNext",
+    "lib": ["esnext", "dom"],
+    "allowJs": true,
+    "checkJs": false,
+    "jsx": "react",
+    "incremental": true,
+    "noEmit": true,
+
+    /* Strict Type-Checking Options */
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+
+    /* Additional Checks */
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": false,
+    "noFallthroughCasesInSwitch": false,
+
+    /* Module Resolution Options */
+    "baseUrl": ".",
+    "paths": {
+      /* Support absolute /imports/* with a leading '/' */
+      "/*": ["*"]
+    },
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "typeRoots": ["./node_modules/@types", "./types"],
+    "types": [
+      "bson",
+      "connect",
+      "iobroker",
+      "meteor",
+      "meteor-roles",
+      "mocha",
+      "mongodb",
+      "node",
+      "node-telegram-bot-api",
+      "prop-types",
+      "react", 
+      "react-dom",
+      "react-router",
+      "react-router-dom",
+      "socket.io-client",
+      "underscore",
+      "ws",
+    ],
+    "esModuleInterop": true,
+    "preserveSymlinks": true
+  },
+  "exclude": [
+    "./.meteor/**",
+    "./packages/**"
+  ]
+}