hoffmation-base 0.1.14 → 0.1.18

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

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

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

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

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

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

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

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

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

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

@@ -1,277 +0,0 @@
-import { LogLevel } from '../../../models/logLevel';
-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 { 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

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

package/tsconfig.json

@@ -1,58 +0,0 @@
-{
-  "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 */
-    "paths": {
-      "/server/config/private/*": ["*"]
-    },
-    "baseUrl": ".",
-    "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/**"
-  ]
-}