hoffmation-base 0.1.14 → 0.1.18

package/lib/server/services/time-callback-service.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeCallbackService = exports.SunTimeOffsets = exports.TimeOfDay = void 0;
+const timeCallback_1 = require("../../models/timeCallback");
+const sunrise_sunset_js_1 = require("sunrise-sunset-js");
+const log_service_1 = require("./log-service");
+const logLevel_1 = require("../../models/logLevel");
+const devices_1 = require("../devices/devices");
+const utils_1 = require("./utils/utils");
+const settings_service_1 = require("./settings-service");
+var TimeOfDay;
+(function (TimeOfDay) {
+    TimeOfDay[TimeOfDay["BeforeSunrise"] = 1] = "BeforeSunrise";
+    TimeOfDay[TimeOfDay["Daylight"] = 2] = "Daylight";
+    TimeOfDay[TimeOfDay["AfterSunset"] = 3] = "AfterSunset";
+    TimeOfDay[TimeOfDay["Night"] = 4] = "Night";
+})(TimeOfDay = exports.TimeOfDay || (exports.TimeOfDay = {}));
+class SunTimeOffsets {
+    constructor(sunrise = 0, sunset = 0, minimumHours = 6, minimumMinutes = 24, maximumHours = 22, maximumMinutes = 30) {
+        this.sunrise = sunrise;
+        this.sunset = sunset;
+        this.minimumHours = minimumHours;
+        this.minimumMinutes = minimumMinutes;
+        this.maximumHours = maximumHours;
+        this.maximumMinutes = maximumMinutes;
+    }
+    getNextMinimumSunrise() {
+        const today = new Date(new Date().setHours(this.minimumHours, this.minimumMinutes));
+        if (today > new Date()) {
+            return today;
+        }
+        return new Date(today.getTime() + 24 * 60 * 60 * 1000);
+    }
+    getNextMaximumSunset() {
+        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);
+    }
+}
+exports.SunTimeOffsets = SunTimeOffsets;
+class TimeCallbackService {
+    static dayType(pOffset) {
+        const now = new Date();
+        const hours = now.getHours();
+        const minutes = now.getMinutes();
+        const nightEnd = settings_service_1.SettingsService.settings.timeSettings.nightEnd;
+        const nightStart = settings_service_1.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 = new Date(TimeCallbackService._todaySunSet.getTime() + pOffset.sunset * 60 * 1000);
+        const maximumSunset = pOffset.getNextMaximumSunset();
+        if (maximumSunset.getDate() !== sunset.getDate()) {
+            maximumSunset.setDate(maximumSunset.getDate() - 1);
+        }
+        if (maximumSunset < sunset && maximumSunset.getDate() === sunset.getDate()) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.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 = pOffset.getNextMinimumSunrise();
+        let sunrise = new Date(TimeCallbackService._todaySunRise.getTime() + pOffset.sunset * 60 * 1000);
+        if (minimumSunrise.getDate() !== sunrise.getDate()) {
+            minimumSunrise.setDate(minimumSunrise.getDate() - 1);
+        }
+        if (minimumSunrise > sunrise && minimumSunrise.getDate() === sunrise.getDate()) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Minimum Sunset nach aktuellem Sunrise: Sunset ${sunrise.toLocaleString()}\t\t${minimumSunrise.toLocaleString()}`);
+            sunrise = minimumSunrise;
+        }
+        if (now < sunrise && now.getDate() == sunrise.getDate()) {
+            return TimeOfDay.BeforeSunrise;
+        }
+        return TimeOfDay.Daylight;
+    }
+    static darkOutsideOrNight(dayType) {
+        switch (dayType) {
+            case TimeOfDay.Night:
+            case TimeOfDay.BeforeSunrise:
+            case TimeOfDay.AfterSunset:
+                return true;
+            default:
+                return false;
+        }
+    }
+    static stopInterval() {
+        if (this._iCheck !== undefined) {
+            clearInterval(this._iCheck);
+            this._iCheck = undefined;
+        }
+    }
+    static get nextSunRise() {
+        return TimeCallbackService._nextSunRise;
+    }
+    static get nextSunSet() {
+        return TimeCallbackService._nextSunSet;
+    }
+    static init() {
+        const dailyRecalc = new timeCallback_1.TimeCallback('Midnight Recalc', timeCallback_1.TimeCallbackType.TimeOfDay, () => {
+            TimeCallbackService.recalcSunTimes();
+            devices_1.Devices.midnightReset();
+        }, 0, 0, 0);
+        const daily3oClockRecalc = new timeCallback_1.TimeCallback('Daily3oClockRecalc', timeCallback_1.TimeCallbackType.TimeOfDay, () => {
+            devices_1.Devices.resetPraesenzCount();
+        }, 0, 3, 0);
+        TimeCallbackService.recalcSunTimes();
+        TimeCallbackService.addCallback(dailyRecalc);
+        TimeCallbackService.addCallback(daily3oClockRecalc);
+        this._iCheck = utils_1.Utils.guardedInterval(TimeCallbackService.performCheck, 60000);
+    }
+    static addCallback(pCallback) {
+        TimeCallbackService._callbacks.push(pCallback);
+    }
+    static performCheck() {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Perform TimeCallBackCheck`);
+        const now = 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 = new Date(new Date().setHours(2, 0, 0, 0) + 24 * 60 * 60 * 1000);
+            TimeCallbackService.updateSunRise(tomorow);
+        }
+        if (TimeCallbackService._nextSunSet < now) {
+            const tomorow = new Date(new Date().setHours(2, 0, 0, 0) + 24 * 60 * 60 * 1000);
+            TimeCallbackService.updateSunSet(tomorow);
+        }
+        TimeCallbackService._lastCheck = now;
+    }
+    static recalcSunTimes() {
+        TimeCallbackService._todaySunRise = (0, sunrise_sunset_js_1.getSunrise)(51.529556852253826, 7.097266042276687, new Date());
+        TimeCallbackService._todaySunSet = (0, sunrise_sunset_js_1.getSunset)(51.529556852253826, 7.097266042276687, new Date());
+        TimeCallbackService.updateSunSet();
+        TimeCallbackService.updateSunRise();
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Nächster Sonnenaufgang um ${TimeCallbackService.nextSunRise.toLocaleTimeString('de-DE')}
+Nächster Sonnenuntergang um ${TimeCallbackService._nextSunSet.toLocaleTimeString('de-DE')}`);
+    }
+    static removeCallback(pCallback) {
+        for (let i = 0; i < TimeCallbackService._callbacks.length; i++) {
+            const cb = TimeCallbackService._callbacks[i];
+            if (cb.name !== pCallback.name) {
+                continue;
+            }
+            TimeCallbackService._callbacks.splice(i, 1);
+            return;
+        }
+    }
+    static updateSunRise(pDay = new Date()) {
+        TimeCallbackService._nextSunRise = (0, sunrise_sunset_js_1.getSunrise)(51.529556852253826, 7.097266042276687, pDay);
+    }
+    static updateSunSet(pDay = new Date()) {
+        TimeCallbackService._nextSunSet = (0, sunrise_sunset_js_1.getSunset)(51.529556852253826, 7.097266042276687, pDay);
+    }
+}
+exports.TimeCallbackService = TimeCallbackService;
+TimeCallbackService._callbacks = [];
+TimeCallbackService._lastCheck = new Date(0);

package/lib/server/services/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './ringstorage';

package/lib/server/services/utils/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./ringstorage"), exports);

package/lib/server/services/utils/ringstorage.d.ts

@@ -0,0 +1,8 @@
+export declare class ringStorage {
+    private maxSize;
+    private storage;
+    private pointer;
+    constructor(maxSize?: number);
+    add(text: string): void;
+    readAmount(amount: number): string[];
+}

package/lib/server/services/utils/ringstorage.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ringStorage = void 0;
+class ringStorage {
+    constructor(maxSize = 10) {
+        this.maxSize = maxSize;
+        this.storage = [];
+        this.pointer = 0;
+    }
+    add(text) {
+        this.pointer = (this.pointer + 1) % this.maxSize;
+        this.storage[this.pointer] = text;
+    }
+    readAmount(amount) {
+        const result = [];
+        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;
+    }
+}
+exports.ringStorage = ringStorage;

package/lib/server/services/utils/utils.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export declare class Utils {
+    static guardedFunction(func: (...args: unknown[]) => void, thisContext: unknown | undefined): void;
+    static nowMS(): number;
+    static guardedNewThread(func: (...args: unknown[]) => void, thisContext?: unknown | undefined): void;
+    static guardedTimeout(func: (...args: unknown[]) => void, time: number, thisContext?: unknown | undefined): NodeJS.Timeout;
+    static guardedInterval(func: (...args: unknown[]) => void, time: number, thisContext?: unknown | undefined, fireImmediate?: boolean): NodeJS.Timeout;
+    static nowString(): string;
+}

package/lib/server/services/utils/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+const log_service_1 = require("../log-service");
+const logLevel_1 = require("../../../models/logLevel");
+class Utils {
+    static guardedFunction(func, thisContext) {
+        try {
+            if (thisContext) {
+                func.bind(thisContext)();
+            }
+            else {
+                func();
+            }
+        }
+        catch (e) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Guarded Function failed: ${e.message}\n Stack: ${e.stack}`);
+        }
+    }
+    static nowMS() {
+        return new Date().getTime();
+    }
+    static guardedNewThread(func, thisContext) {
+        Utils.guardedTimeout(func, 1, thisContext);
+    }
+    static guardedTimeout(func, time, thisContext) {
+        return setTimeout(() => {
+            Utils.guardedFunction(func, thisContext);
+        }, time);
+    }
+    static guardedInterval(func, time, thisContext, fireImmediate = false) {
+        if (fireImmediate) {
+            Utils.guardedFunction(func, thisContext);
+        }
+        return setInterval(() => {
+            Utils.guardedFunction(func, thisContext);
+        }, time);
+    }
+    static nowString() {
+        const d = new Date();
+        return `${d.toLocaleTimeString('de-DE')}.${d.getMilliseconds()}`;
+    }
+}
+exports.Utils = Utils;

package/lib/server/services/weather/index.d.ts

@@ -0,0 +1,9 @@
+export * from './weather-item';
+export * from './weather-temp';
+export * from './weather-alert';
+export * from './weather-daily';
+export * from './weather-hourly';
+export * from './weather-current';
+export * from './weather-minutes';
+export * from './weather-service';
+export * from './weather-feelsLike';

package/lib/server/services/weather/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./weather-item"), exports);
+__exportStar(require("./weather-temp"), exports);
+__exportStar(require("./weather-alert"), exports);
+__exportStar(require("./weather-daily"), exports);
+__exportStar(require("./weather-hourly"), exports);
+__exportStar(require("./weather-current"), exports);
+__exportStar(require("./weather-minutes"), exports);
+__exportStar(require("./weather-service"), exports);
+__exportStar(require("./weather-feelsLike"), exports);

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

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

package/lib/server/services/weather/weather-alert.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,25 @@
+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/lib/server/services/weather/weather-current.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,21 @@
+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/lib/server/services/weather/weather-daily.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/server/services/weather/weather-feelsLike.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,16 @@
+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/lib/server/services/weather/weather-hourly.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/server/services/weather/weather-item.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/server/services/weather/weather-minutes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,37 @@
+import { OwnSonosDevice } 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';
+export interface WeatherResponse {
+    lat: number;
+    lon: number;
+    timezone: string;
+    timezone_offset: number;
+    current: WeatherCurrent;
+    minutely: WeatherMinutes[];
+    hourly: WeatherHourly[];
+    daily: WeatherDaily[];
+    alerts?: WeatherAlert[];
+}
+export declare class WeatherService {
+    static active: boolean;
+    static oneDay: number;
+    static lastResponse: WeatherResponse;
+    private static _refreshInterval;
+    private static latitude;
+    private static longitude;
+    private static appID;
+    static initialize(config: iWeatherSettings): void;
+    static stopInterval(): void;
+    static playWeatherInfo(sonosDevice: OwnSonosDevice, volume?: number, short?: boolean, retries?: number): void;
+    private static getRainNextMinutes;
+    private static getActiveAlerts;
+    private static getWeatherData;
+    static processHourlyWeather(): void;
+    static getCurrentTemp(): number;
+    static isOutsideWarmer(currentTemperatur: number): boolean;
+    static weatherRolloPosition(normalPos: number, desiredTemperatur: number, currentTemperatur: number): number;
+}

package/lib/server/services/weather/weather-service.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeatherService = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const https_service_1 = require("../https-service");
+const HTTPSOptions_1 = require("../HTTPSOptions");
+const log_service_1 = require("../log-service");
+const sonos_service_1 = require("../Sonos/sonos-service");
+const utils_1 = require("../utils/utils");
+class WeatherService {
+    static initialize(config) {
+        this.active = true;
+        this.longitude = config.longitude;
+        this.latitude = config.lattitude;
+        this.appID = config.appid;
+        this._refreshInterval = utils_1.Utils.guardedInterval(WeatherService.getWeatherData, 10 * 60 * 1000, WeatherService, true);
+    }
+    static stopInterval() {
+        if (this._refreshInterval !== undefined) {
+            clearInterval(this._refreshInterval);
+            this._refreshInterval = undefined;
+        }
+    }
+    static playWeatherInfo(sonosDevice, volume = 30, short = false, retries = 5) {
+        const wData = WeatherService.lastResponse;
+        if (wData === undefined) {
+            if (retries > 0) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `WeatherService.playWeatherInfo(): Der Wetterbericht ist noch nicht bereit --> warten`);
+                setTimeout(() => {
+                    WeatherService.playWeatherInfo(sonosDevice, volume, short, retries - 1);
+                }, 1000);
+            }
+            else {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `WeatherService.playWeatherInfo(): Der Wetterbericht ist vorhanden --> Abbruch`);
+            }
+            return;
+        }
+        sonos_service_1.SonosService.speakOnDevice(short ? `Kurze Wetterinfo:` : `HoffMation Wetter-Bericht:`, sonosDevice, volume, false);
+        sonos_service_1.SonosService.speakOnDevice(`Wetterbeschreibung für heute:  ${wData.daily[0].weather[0].description}`, sonosDevice, volume, false);
+        sonos_service_1.SonosService.speakOnDevice(`Aktuell sind es ${Math.round(wData.current.temp)} Grad.`, sonosDevice, volume, false);
+        if (!short) {
+            sonos_service_1.SonosService.speakOnDevice(`Heute sollen es im Durchschnitt ${Math.round(wData.daily[0].temp.day)} Grad sein.`, sonosDevice, volume, false);
+            sonos_service_1.SonosService.speakOnDevice(`Die Höchsttemperatur liegt heute bei ${Math.round(wData.daily[0].temp.max)} Grad.`, sonosDevice, volume, false);
+            sonos_service_1.SonosService.speakOnDevice(`Die Tiefsttemperatur soll heute ${Math.round(wData.daily[0].temp.min)} Grad betragen.`, sonosDevice, volume, false);
+            if (wData.daily[0].rain !== undefined) {
+                sonos_service_1.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) {
+            sonos_service_1.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 = 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;
+        }
+        sonos_service_1.SonosService.speakOnDevice(message, sonosDevice, volume, false);
+        !short &&
+            precipitation > 0 &&
+            sonos_service_1.SonosService.speakOnDevice(`Es werden etwa ${precipitation} Millimeter Niederschlag in den nächsten ${minutes} Minuten fallen`, sonosDevice, volume, false);
+        const alerts = WeatherService.getActiveAlerts();
+        if (alerts.length > 0) {
+            const alertMessage = [`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}`)
+            });
+            sonos_service_1.SonosService.speakOnDevice(alertMessage.join('\n'), sonosDevice, volume, false);
+        }
+        else if (!short) {
+            sonos_service_1.SonosService.speakOnDevice(`Für heute liegt keine Unwetterwarnungen vor`, sonosDevice, volume, false);
+        }
+    }
+    static getRainNextMinutes() {
+        const minutes = WeatherService.lastResponse.minutely;
+        let minutesUsed = 0;
+        let precipitation = 0;
+        if (minutes !== undefined) {
+            const now = new Date().getTime();
+            minutes.forEach((element) => {
+                if (element.dt * 1000 > now) {
+                    minutesUsed++;
+                    precipitation += element.precipitation;
+                }
+            });
+        }
+        return { minutes: minutesUsed, precipitation: precipitation };
+    }
+    static getActiveAlerts() {
+        const result = [];
+        if (WeatherService.lastResponse.alerts === undefined || WeatherService.lastResponse.alerts.length === 0) {
+            return result;
+        }
+        const now = new Date().getTime();
+        const todayMidnight = new Date().setHours(0, 0, 0, 0);
+        const tomorowMidnight = todayMidnight + WeatherService.oneDay;
+        WeatherService.lastResponse.alerts.forEach((element) => {
+            const timestampStart = element.start * 1000;
+            if ((timestampStart > todayMidnight && timestampStart < tomorowMidnight) ||
+                (timestampStart < now && element.end * 1000 > now)) {
+                result.push(element);
+            }
+        });
+        return result;
+    }
+    static getWeatherData() {
+        https_service_1.HTTPSService.request(new HTTPSOptions_1.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) => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `WeatherAPi Response erhalten`);
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `WeatherAPi Response: ${response}`);
+            utils_1.Utils.guardedFunction(() => {
+                WeatherService.lastResponse = JSON.parse(response);
+                WeatherService.processHourlyWeather();
+            }, this);
+        });
+    }
+    static processHourlyWeather() {
+        log_service_1.ServerLogService.writeLog(logLevel_1.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 = [`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}`);
+            });
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, message.join('\n'));
+        }
+    }
+    static getCurrentTemp() {
+        const wData = WeatherService.lastResponse;
+        if (wData === undefined || wData.current === undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `WeatherService.isOutsideWarmer(): There are no data yet`);
+            return -99;
+        }
+        return wData.current.temp;
+    }
+    static isOutsideWarmer(currentTemperatur) {
+        const wData = WeatherService.lastResponse;
+        if (wData === undefined || wData.current === undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `WeatherService.isOutsideWarmer(): There are no data yet`);
+            return false;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `isOutsideWarmer(${currentTemperatur}) --> Aktuelle Temperatur: ${wData.current.temp}`);
+        return currentTemperatur < wData.current.temp;
+    }
+    static weatherRolloPosition(normalPos, desiredTemperatur, currentTemperatur) {
+        let result = normalPos;
+        if (currentTemperatur > desiredTemperatur && this.isOutsideWarmer(currentTemperatur) && normalPos > 30) {
+            // Draußen ist wärmer also runter
+            result = 30;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `weatherRolloPosition(${normalPos}, ${desiredTemperatur}, ${currentTemperatur}) --> Target: ${result}`);
+        return result;
+    }
+}
+exports.WeatherService = WeatherService;
+WeatherService.active = false;
+WeatherService.oneDay = 1000 * 60 * 60 * 24;