hoffmation-base 3.0.0-alpha.5 → 3.0.0-alpha.50

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

@@ -1,14 +1,17 @@
 /// <reference types="node" />
 import { iPersist } from '../dbo';
+import { CatchEmResult } from './catchEmResult';
+import { iTimePair } from '../../config';
+import { RGB } from './RGB';
 export declare const DAYMS: number;
 export declare class Utils {
+    /**
+     * The persitence layer object
+     */
     static dbo: iPersist | undefined;
     static get anyDboActive(): boolean;
     static get timeTilMidnight(): number;
-    static catchEm<T>(promise: Promise<T>): Promise<{
-        reason: Error | null;
-        data: T | null;
-    }>;
+    static catchEm<T>(promise: Promise<T>): Promise<CatchEmResult<T>>;
     static guardedFunction(func: (...args: unknown[]) => void, thisContext: unknown | undefined): void;
     static nowMS(): number;
     static delay(ms: number): Promise<void>;
@@ -23,10 +26,7 @@ export declare class Utils {
     static round(number: number, digits: number): number;
     static roundDot5(number: number): number;
     static beetweenDays(date: Date, startDay: number, endDay: number): boolean;
-    static nowTime(): {
-        hours: number;
-        minutes: number;
-    };
+    static nowTime(): iTimePair;
     static dateByTimeSpan(hours: number, minutes: number, now?: Date): Date;
     static positiveMod(number: number, mod: number): number;
     static degreeInBetween(minDegree: number, maxDegree: number, degreeToCheck: number): boolean;
@@ -34,9 +34,5 @@ export declare class Utils {
     static nextMatchingDate(hours?: number, minutes?: number, now?: Date): Date;
     static timeWithinBorders(minimumHours: number, minimumMinutes: number, maxHours: number, maxMinutes: number, now?: Date): boolean;
     static formatHex(hex: string): string | null;
-    static hexToRgb(color: string): {
-        r: number;
-        g: number;
-        b: number;
-    } | null;
+    static hexToRgb(color: string): RGB | null;
 }

package/lib/server/services/victron/victron-device.d.ts

@@ -1,13 +1,16 @@
-import { DeviceInfo, DeviceType, iEnergyManager, iExcessEnergyConsumer } from '../../devices';
-import { LogLevel, VictronDeviceSettings } from '../../../models';
-import { DeviceCapability } from '../../devices/DeviceCapability';
+import { DeviceCapability, DeviceInfo, DeviceType, iBatteryDevice, iEnergyManager, iExcessEnergyConsumer } from '../../devices';
+import { BatteryLevelChangeAction, LogLevel, VictronDeviceSettings } from '../../../models';
 import { LogDebugType } from '../log-service';
 import { VictronDeviceData, VictronMqttConnectionOptions, VictronMqttConsumer } from 'victron-mqtt-consumer';
-export declare class VictronDevice implements iEnergyManager {
-    private readonly _victronConsumer;
+export declare class VictronDevice implements iEnergyManager, iBatteryDevice {
+    /** @inheritDoc */
     readonly deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
     deviceType: DeviceType;
+    /** @inheritDoc */
     readonly settings: VictronDeviceSettings;
+    protected _info: DeviceInfo;
+    private readonly _victronConsumer;
     private _excessEnergyConsumer;
     private blockDeviceChangeTime;
     private _lastDeviceChange;
@@ -15,30 +18,43 @@ export declare class VictronDevice implements iEnergyManager {
     private _iDatabaseLoggerInterval;
     private _lastPersistenceCalculation;
     private _nextPersistEntry;
+    private _lastBatteryPersist;
+    private _lastBatteryLevel;
+    private _batteryLevelCallbacks;
+    private _excessEnergy;
     constructor(opts: VictronMqttConnectionOptions);
-    protected _info: DeviceInfo;
+    /** @inheritDoc */
+    get acBlocked(): boolean;
+    /** @inheritDoc */
+    get lastBatteryPersist(): number;
     get info(): DeviceInfo;
+    /** @inheritDoc */
+    get battery(): number;
     get victronConsumer(): VictronMqttConsumer;
     get data(): VictronDeviceData;
-    private _excessEnergy;
     get excessEnergy(): number;
     get name(): string;
     get customName(): string;
     get id(): string;
-    addExcessConsumer(device: iExcessEnergyConsumer): void;
     get injectingWattage(): number;
     get drawingWattage(): number;
     get selfConsumingWattage(): number;
-    cleanup(): void;
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    addExcessConsumer(device: iExcessEnergyConsumer): void;
+    /** @inheritDoc */
+    dispose(): void;
     getReport(): string;
     recalculatePowerSharing(): void;
     loadDeviceSettings(): void;
     log(level: LogLevel, message: string, debugType?: LogDebugType): void;
     persistDeviceInfo(): void;
+    /** @inheritDoc */
+    persistBatteryDevice(): void;
     toJSON(): Partial<VictronDevice>;
     /**
      * Changes the grid set point of the Victron device, to the desired value.
-     * @param {number} setPoint
+     * @param setPoint - The desired watt point the system should aim for.
      */
     setGridSetPoint(setPoint: number): void;
     private calculateExcessEnergy;
@@ -46,4 +62,5 @@ export declare class VictronDevice implements iEnergyManager {
     private turnOffAdditionalConsumer;
     private persist;
     private calculatePersistenceValues;
+    private checkForBatteryChange;
 }

package/lib/server/services/victron/victron-device.js

@@ -4,31 +4,40 @@ exports.VictronDevice = void 0;
 const devices_1 = require("../../devices");
 const utils_1 = require("../utils");
 const models_1 = require("../../../models");
-const DeviceCapability_1 = require("../../devices/DeviceCapability");
 const log_service_1 = require("../log-service");
 const victron_mqtt_consumer_1 = require("victron-mqtt-consumer");
 const time_callback_service_1 = require("../time-callback-service");
+const lodash_1 = require("lodash");
 class VictronDevice {
     constructor(opts) {
-        this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.energyManager];
+        /** @inheritDoc */
+        this.deviceCapabilities = [
+            devices_1.DeviceCapability.energyManager,
+            devices_1.DeviceCapability.batteryDriven,
+        ];
+        /** @inheritDoc */
         this.deviceType = devices_1.DeviceType.Victron;
         this._excessEnergyConsumer = [];
         this.blockDeviceChangeTime = -1;
         this._iCalculationInterval = null;
         this._iDatabaseLoggerInterval = null;
         this._lastPersistenceCalculation = utils_1.Utils.nowMS();
+        this._lastBatteryPersist = 0;
+        this._lastBatteryLevel = -1;
+        this._batteryLevelCallbacks = [];
         this._excessEnergy = 0;
         this.settings = new models_1.VictronDeviceSettings();
         this._info = new devices_1.DeviceInfo();
-        this._info.fullName = `Victron Device`;
-        this._info.customName = `Victron`;
-        this._info.allDevicesKey = `victron`;
-        devices_1.Devices.alLDevices[`victron`] = this;
+        this._info.fullName = 'Victron Device';
+        this._info.customName = 'Victron';
+        this._info.allDevicesKey = 'victron';
+        devices_1.Devices.alLDevices['victron'] = this;
         devices_1.Devices.energymanager = this;
         this.persistDeviceInfo();
         this.loadDeviceSettings();
         this._victronConsumer = new victron_mqtt_consumer_1.VictronMqttConsumer(opts);
         this._iCalculationInterval = utils_1.Utils.guardedInterval(() => {
+            this.checkForBatteryChange();
             this.calculateExcessEnergy();
         }, 5 * 1000, this);
         this._iDatabaseLoggerInterval = utils_1.Utils.guardedInterval(() => {
@@ -36,9 +45,36 @@ class VictronDevice {
         }, 15 * 60 * 1000, this);
         this._nextPersistEntry = new models_1.EnergyCalculation(utils_1.Utils.nowMS());
     }
+    /** @inheritDoc */
+    get acBlocked() {
+        if (this.settings.hasBattery) {
+            const hours = new Date().getHours();
+            if (hours < 6 || hours > 18) {
+                return this.battery < 70;
+            }
+            if (hours < 10 || hours > 16) {
+                return this.battery < 60;
+            }
+            return this.battery < 50;
+        }
+        return false;
+    }
+    /** @inheritDoc */
+    get lastBatteryPersist() {
+        return this._lastBatteryPersist;
+    }
     get info() {
         return this._info;
     }
+    /** @inheritDoc */
+    get battery() {
+        const level = this.data.battery.soc;
+        if (level == null) {
+            this.log(models_1.LogLevel.Debug, 'No battery data available from Victron device.');
+            return -1;
+        }
+        return level;
+    }
     get victronConsumer() {
         return this._victronConsumer;
     }
@@ -58,9 +94,6 @@ class VictronDevice {
         var _a;
         return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `victron-${this.info.room}-${this.info.customName}`;
     }
-    addExcessConsumer(device) {
-        this._excessEnergyConsumer.push(device);
-    }
     get injectingWattage() {
         var _a;
         return Math.min((_a = this.victronConsumer.data.grid.power) !== null && _a !== void 0 ? _a : 0, 0) * -1;
@@ -73,7 +106,15 @@ class VictronDevice {
         var _a;
         return Math.max((_a = this.victronConsumer.data.system.power) !== null && _a !== void 0 ? _a : 0, 0) - this.drawingWattage;
     }
-    cleanup() {
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this._batteryLevelCallbacks.push(pCallback);
+    }
+    addExcessConsumer(device) {
+        this._excessEnergyConsumer.push(device);
+    }
+    /** @inheritDoc */
+    dispose() {
         this._victronConsumer.disconnect();
         if (this._iDatabaseLoggerInterval !== null) {
             clearInterval(this._iDatabaseLoggerInterval);
@@ -117,12 +158,29 @@ class VictronDevice {
             (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
         }, 5000, this);
     }
+    /** @inheritDoc */
+    persistBatteryDevice() {
+        var _a;
+        const now = utils_1.Utils.nowMS();
+        if (this._lastBatteryPersist + 60000 > now) {
+            return;
+        }
+        (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
+        this._lastBatteryPersist = now;
+    }
     toJSON() {
-        return utils_1.Utils.jsonFilter(this, ['_victronConsumer']);
+        return (0, lodash_1.extend)(utils_1.Utils.jsonFilter(this, ['_victronConsumer', '_excessEnergyConsumer']), {
+            battery: this.battery,
+            acBlocked: this.acBlocked,
+            excessEnergy: this.excessEnergy,
+            drawingWattage: this.drawingWattage,
+            injectingWattage: this.injectingWattage,
+            selfConsumingWattage: this.selfConsumingWattage,
+        });
     }
     /**
      * Changes the grid set point of the Victron device, to the desired value.
-     * @param {number} setPoint
+     * @param setPoint - The desired watt point the system should aim for.
      */
     setGridSetPoint(setPoint) {
         this._victronConsumer.setGridSetPoint(setPoint);
@@ -131,7 +189,7 @@ class VictronDevice {
         var _a;
         this._excessEnergy = 0;
         if (this.data == undefined) {
-            this.log(models_1.LogLevel.Debug, `No data available from Victron device.`);
+            this.log(models_1.LogLevel.Debug, 'No data available from Victron device.');
             return;
         }
         // Step 1: Calculate battery need
@@ -139,11 +197,11 @@ class VictronDevice {
         let neededBatteryWattage = 0;
         const timeOfDay = time_callback_service_1.TimeCallbackService.dayType(new time_callback_service_1.SunTimeOffsets());
         if (this.settings.hasBattery && timeOfDay !== models_1.TimeOfDay.AfterSunset && timeOfDay !== models_1.TimeOfDay.Night) {
-            if (this.data.battery.soc == null) {
-                this.log(models_1.LogLevel.Debug, `No battery data available from Victron device.`);
+            if (this.battery < 0) {
+                this.log(models_1.LogLevel.Debug, 'No battery data available from Victron device.');
                 return;
             }
-            neededBatteryWattage = ((1 - this.data.battery.soc) * this.settings.batteryCapacityWattage) / hoursTilSunset;
+            neededBatteryWattage = ((1 - this.battery / 100.0) * this.settings.batteryCapacityWattage) / hoursTilSunset;
             // Step 2: Calculate expected solar output
             const solarOutput = (_a = this.data.pvInverter.power) !== null && _a !== void 0 ? _a : 0;
             // Step 3: Calculate expected base consumption
@@ -152,22 +210,22 @@ class VictronDevice {
             this._excessEnergy = solarOutput - neededBatteryWattage - baseConsumption;
         }
         let isSocTooLow = false;
-        if (this.data.battery.dcPower !== null && this.data.battery.soc !== null) {
+        if (this.data.battery.dcPower !== null && this.battery > -1) {
             if (timeOfDay === models_1.TimeOfDay.Night) {
-                isSocTooLow = this.data.battery.soc < 0.5;
+                isSocTooLow = this.battery < 50;
             }
             else if (timeOfDay === models_1.TimeOfDay.AfterSunset) {
-                isSocTooLow = this.data.battery.soc < 0.75;
+                isSocTooLow = this.battery < 75;
             }
             else if (hoursTilSunset > 4) {
-                isSocTooLow = this.data.battery.soc < 0.7;
+                isSocTooLow = this.battery < 70;
             }
             else {
-                isSocTooLow = this.data.battery.soc < 0.8;
+                isSocTooLow = this.battery < 80;
             }
         }
         // Whilst calculated spare energy is more precise, we don't mind using the battery as a buffer, if it is full enough.
-        if (this.data.battery.dcPower !== null && this.data.battery.soc !== null && !isSocTooLow) {
+        if (this.data.battery.dcPower !== null && this.battery > -1 && !isSocTooLow) {
             this._excessEnergy = this.settings.maximumBatteryDischargeWattage - Math.max(this.data.battery.dcPower, 0);
         }
         this.calculatePersistenceValues();
@@ -193,14 +251,13 @@ class VictronDevice {
         }
         if (!result.newState) {
             this.blockDeviceChangeTime = utils_1.Utils.nowMS() + result.device.energySettings.powerReactionTime;
-            result.device.log(models_1.LogLevel.Info, `Turning off, as we don't have energy to spare...`);
+            result.device.log(models_1.LogLevel.Info, "Turning off, as we don't have energy to spare...");
             result.device.turnOffDueToMissingEnergy();
             this._lastDeviceChange = result;
         }
     }
     persist() {
-        var _a;
-        this._nextPersistEntry.batteryLevel = ((_a = this.data.battery.soc) !== null && _a !== void 0 ? _a : 0) / 100;
+        this._nextPersistEntry.batteryLevel = this.battery / 100;
         this._nextPersistEntry.batteryStoredKwH =
             (this._nextPersistEntry.batteryLevel * this.settings.batteryCapacityWattage) / 1000;
         const obj = JSON.parse(JSON.stringify(this._nextPersistEntry));
@@ -217,5 +274,15 @@ class VictronDevice {
         this._nextPersistEntry.selfConsumedKwH += utils_1.Utils.kWh(this.selfConsumingWattage, duration);
         this._lastPersistenceCalculation = now;
     }
+    checkForBatteryChange() {
+        const newLevel = this.battery;
+        if (newLevel == this._lastBatteryLevel) {
+            return;
+        }
+        for (const cb of this._batteryLevelCallbacks) {
+            cb(new models_1.BatteryLevelChangeAction(this));
+        }
+        this._lastBatteryLevel = newLevel;
+    }
 }
 exports.VictronDevice = VictronDevice;

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

@@ -7,3 +7,5 @@ export * from './weather-item';
 export * from './weather-minutes';
 export * from './weather-service';
 export * from './weather-temp';
+export { WeatherResponse } from './weather-response';
+export { RainNextMinutesInfo } from './rain-next-minutes-info';

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

@@ -14,6 +14,7 @@ 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 });
+exports.RainNextMinutesInfo = void 0;
 __exportStar(require("./weather-alert"), exports);
 __exportStar(require("./weather-current"), exports);
 __exportStar(require("./weather-daily"), exports);
@@ -23,3 +24,5 @@ __exportStar(require("./weather-item"), exports);
 __exportStar(require("./weather-minutes"), exports);
 __exportStar(require("./weather-service"), exports);
 __exportStar(require("./weather-temp"), exports);
+var rain_next_minutes_info_1 = require("./rain-next-minutes-info");
+Object.defineProperty(exports, "RainNextMinutesInfo", { enumerable: true, get: function () { return rain_next_minutes_info_1.RainNextMinutesInfo; } });

package/lib/server/services/weather/rain-next-minutes-info.d.ts

@@ -0,0 +1,5 @@
+export declare class RainNextMinutesInfo {
+    minutes: number;
+    precipitation: number;
+    constructor(minutes: number, precipitation: number);
+}

package/lib/server/services/weather/rain-next-minutes-info.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RainNextMinutesInfo = void 0;
+class RainNextMinutesInfo {
+    constructor(minutes, precipitation) {
+        this.minutes = minutes;
+        this.precipitation = precipitation;
+    }
+}
+exports.RainNextMinutesInfo = RainNextMinutesInfo;

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

@@ -2,8 +2,6 @@ import { WeatherItem } from './weather-item';
 export interface WeatherCurrent {
     /**
      * Zeit der Anfrage
-     * @type {number}
-     * @memberof WeatherCurrent
      */
     dt: number;
     sunrise: number;

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

@@ -1,6 +1,21 @@
+/**
+ * Temperature data how its recognized by a human for the different times of the day.
+ */
 export interface WeatherFeelsLike {
+    /**
+     * Day temperature in Celsius
+     */
     day: number;
+    /**
+     * Night temperature in Celsius
+     */
     night: number;
+    /**
+     * Evening temperature in Celsius
+     */
     eve: number;
+    /**
+     * Morning temperature in Celsius
+     */
     morn: number;
 }

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

@@ -0,0 +1,16 @@
+import { WeatherCurrent } from './weather-current';
+import { WeatherMinutes } from './weather-minutes';
+import { WeatherHourly } from './weather-hourly';
+import { WeatherDaily } from './weather-daily';
+import { WeatherAlert } from './weather-alert';
+export interface WeatherResponse {
+    lat: number;
+    lon: number;
+    timezone: string;
+    timezone_offset: number;
+    current: WeatherCurrent;
+    minutely: WeatherMinutes[];
+    hourly: WeatherHourly[];
+    daily: WeatherDaily[];
+    alerts?: WeatherAlert[];
+}

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

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

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

@@ -1,30 +1,23 @@
-import { WeatherHourly } from './weather-hourly';
-import { WeatherCurrent } from './weather-current';
-import { WeatherMinutes } from './weather-minutes';
-import { WeatherAlert } from './weather-alert';
 import { iWeatherSettings } from '../../config';
 import { LogLevel, ShutterSettings } from '../../../models';
 import { LogDebugType } from '../log-service';
-import { WeatherDaily } from './weather-daily';
 import { iSpeaker } from '../../devices';
-export interface WeatherResponse {
-    lat: number;
-    lon: number;
-    timezone: string;
-    timezone_offset: number;
-    current: WeatherCurrent;
-    minutely: WeatherMinutes[];
-    hourly: WeatherHourly[];
-    daily: WeatherDaily[];
-    alerts?: WeatherAlert[];
-}
+import { WeatherResponse } from './weather-response';
 export declare class WeatherService {
+    /**
+     * Whether the service is active or not
+     */
     static active: boolean;
-    static oneDay: number;
+    /**
+     * The milliseconds of one day
+     */
+    static readonly oneDay: number;
+    /**
+     * The last weather response
+     */
     static lastResponse: WeatherResponse;
     /**
      * The sun horizontal degree (0 is North)
-     * @type {number}
      */
     static sunDirection: number;
     private static _dataUpdateCbs;
@@ -46,5 +39,9 @@ export declare class WeatherService {
     private static getActiveAlerts;
     private static getWeatherData;
     private static recalcAzimuth;
+    /**
+     * Method to calculate the hours until sunset based on the current location
+     * @returns - The hours until sunset
+     */
     private static hoursTilSunset;
 }

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

@@ -36,17 +36,17 @@ class WeatherService {
         const wData = WeatherService.lastResponse;
         if (wData === undefined) {
             if (retries > 0) {
-                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `WeatherService.playWeatherInfo(): Der Wetterbericht ist noch nicht bereit --> warten`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, 'WeatherService.playWeatherInfo(): Der Wetterbericht ist noch nicht bereit --> warten');
                 setTimeout(() => {
                     WeatherService.playWeatherInfo(speaker, volume, short, retries - 1);
                 }, 1000);
             }
             else {
-                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `WeatherService.playWeatherInfo(): Der Wetterbericht ist vorhanden --> Abbruch`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, 'WeatherService.playWeatherInfo(): Der Wetterbericht ist vorhanden --> Abbruch');
             }
             return;
         }
-        speaker.speakOnDevice(short ? `Kurze Wetterinfo:` : `HoffMation Wetter-Bericht:`, volume, false);
+        speaker.speakOnDevice(short ? 'Kurze Wetterinfo:' : 'HoffMation Wetter-Bericht:', volume, false);
         speaker.speakOnDevice(`Wetterbeschreibung für heute:  ${wData.daily[0].weather[0].description}`, volume, false);
         speaker.speakOnDevice(`Aktuell sind es ${Math.round(wData.current.temp)} Grad.`, volume, false);
         if (!short) {
@@ -62,25 +62,25 @@ class WeatherService {
         }
         const { minutes, precipitation } = WeatherService.getRainNextMinutes();
         const ratio = minutes <= 0 ? 0 : (precipitation / minutes) * 60;
-        let message = `In der nächsten Zeit `;
+        let message = 'In der nächsten Zeit ';
         switch (true) {
             case ratio > 12:
-                message += `wird es kräftig regnen`;
+                message += 'wird es kräftig regnen';
                 break;
             case ratio > 4:
-                message += `wird es ordentlich regnen`;
+                message += 'wird es ordentlich regnen';
                 break;
             case ratio > 1:
-                message += `wird es regnen`;
+                message += 'wird es regnen';
                 break;
             case ratio > 0.5:
-                message += `wird es mäßig regnen`;
+                message += 'wird es mäßig regnen';
                 break;
             case ratio > 0.1:
-                message += `wird es nieseln regnen`;
+                message += 'wird es nieseln regnen';
                 break;
             default:
-                message += `bleibt es trocken.`;
+                message += 'bleibt es trocken.';
                 break;
         }
         speaker.speakOnDevice(message, volume, false);
@@ -89,7 +89,7 @@ class WeatherService {
             speaker.speakOnDevice(`Es werden etwa ${precipitation} Millimeter Niederschlag in den nächsten ${minutes} Minuten fallen`, volume, false);
         const alerts = WeatherService.getActiveAlerts();
         if (alerts.length > 0) {
-            const alertMessage = [`Achtung, vorliegende Wetterwarnungen:`];
+            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}`)
@@ -97,13 +97,13 @@ class WeatherService {
             speaker.speakOnDevice(alertMessage.join('\n'), volume, false);
         }
         else if (!short) {
-            speaker.speakOnDevice(`Für heute liegt keine Unwetterwarnungen vor`, volume, false);
+            speaker.speakOnDevice('Für heute liegt keine Unwetterwarnungen vor', volume, false);
         }
     }
     static processHourlyWeather() {
         log_service_1.ServerLogService.writeLog(models_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:`];
+            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}`);
             });
@@ -113,7 +113,7 @@ class WeatherService {
     static getCurrentTemp() {
         const wData = WeatherService.lastResponse;
         if (wData === undefined || wData.current === undefined) {
-            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `WeatherService.isOutsideWarmer(): There are no data yet`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'WeatherService.isOutsideWarmer(): There are no data yet');
             return -99;
         }
         return wData.current.temp;
@@ -121,7 +121,7 @@ class WeatherService {
     static willOutsideBeWarmer(referenceTemperature, logger) {
         const wData = WeatherService.lastResponse;
         if (wData === undefined || wData.current === undefined) {
-            logger(models_1.LogLevel.Info, `WeatherService.isOutsideWarmer(): There are no data yet`);
+            logger(models_1.LogLevel.Info, 'WeatherService.isOutsideWarmer(): There are no data yet');
             return false;
         }
         logger(models_1.LogLevel.Info, `willOutsideBeWarmer(${referenceTemperature}) --> Today Max Temperature: ${wData.daily[0].temp.max}`);
@@ -130,24 +130,24 @@ class WeatherService {
     static weatherRolloPosition(normalPos, desiredTemperatur, currentTemperatur, logger, shutterSettings) {
         let result = normalPos;
         if (currentTemperatur < desiredTemperatur) {
-            logger(models_1.LogLevel.Trace, `RolloWeatherPosition: Room needs to heat up anyways.`);
+            logger(models_1.LogLevel.Trace, 'RolloWeatherPosition: Room needs to heat up anyways.');
             return result;
         }
         else if (normalPos < 30) {
-            logger(models_1.LogLevel.Trace, `RolloWeatherPosition: Shutter should be down anyways.`);
+            logger(models_1.LogLevel.Trace, 'RolloWeatherPosition: Shutter should be down anyways.');
             return result;
         }
         else if (this.hoursTilSunset() < 1) {
-            logger(models_1.LogLevel.Trace, `RolloWeatherPosition: It's close to or after todays sunset`);
+            logger(models_1.LogLevel.Trace, "RolloWeatherPosition: It's close to or after todays sunset");
             return result;
         }
         else if (shutterSettings.direction !== undefined &&
             !utils_1.Utils.degreeInBetween(shutterSettings.direction - 50, shutterSettings.direction + 50, this.sunDirection)) {
-            logger(models_1.LogLevel.Trace, `RolloWeatherPosition: Sun is facing a different direction`);
+            logger(models_1.LogLevel.Trace, 'RolloWeatherPosition: Sun is facing a different direction');
             return result;
         }
         else if (this.getCurrentCloudiness() > 40) {
-            logger(models_1.LogLevel.Trace, `RolloWeatherPosition: It´s cloudy now.`);
+            logger(models_1.LogLevel.Trace, 'RolloWeatherPosition: It´s cloudy now.');
         }
         else if (this.willOutsideBeWarmer(26, logger)) {
             result = shutterSettings.heatReductionPosition;
@@ -160,7 +160,7 @@ class WeatherService {
     static getCurrentCloudiness() {
         const wData = WeatherService.lastResponse;
         if (wData === undefined || wData.current === undefined) {
-            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `WeatherService.getCurrentCloudiness(): There are no data yet`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'WeatherService.getCurrentCloudiness(): There are no data yet');
             return 0;
         }
         return wData.current.clouds;
@@ -202,7 +202,7 @@ class WeatherService {
             return;
         }
         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(models_1.LogLevel.Debug, `WeatherAPi Response erhalten`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, 'WeatherAPi Response erhalten');
             log_service_1.ServerLogService.writeLog(models_1.LogLevel.DeepTrace, `WeatherAPi Response: ${response}`);
             utils_1.Utils.guardedFunction(() => {
                 WeatherService.lastResponse = JSON.parse(response);
@@ -218,6 +218,10 @@ class WeatherService {
             180 +
                 (180 / Math.PI) * suncalc_1.default.getPosition(new Date(), parseFloat(this.latitude), parseFloat(this.longitude)).azimuth;
     }
+    /**
+     * Method to calculate the hours until sunset based on the current location
+     * @returns - The hours until sunset
+     */
     static hoursTilSunset() {
         const now = new Date();
         const sunset = time_callback_service_1.TimeCallbackService.getSunsetForDate(now, parseFloat(this.latitude), parseFloat(this.longitude));
@@ -225,6 +229,12 @@ class WeatherService {
     }
 }
 exports.WeatherService = WeatherService;
+/**
+ * Whether the service is active or not
+ */
 WeatherService.active = false;
+/**
+ * The milliseconds of one day
+ */
 WeatherService.oneDay = 1000 * 60 * 60 * 24;
 WeatherService._dataUpdateCbs = {};