hoffmation-base 3.0.2 → 3.1.0

package/lib/services/room-service/room-service.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomService = void 0;
+const command_1 = require("../../command");
+const utils_1 = require("../../utils");
+const enums_1 = require("../../enums");
+const logging_1 = require("../../logging");
+const Sonos_1 = require("../Sonos");
+const i18n_1 = require("../../i18n");
+const Telegram_1 = require("../Telegram");
+class RoomService {
+    static addToRoomList(room) {
+        RoomService.Rooms.set(room.roomName, room);
+    }
+    static getAllRoomsOfFloor(floor) {
+        return [...this.Rooms].filter(([_name, room]) => room.etage === floor).values();
+    }
+    /**
+     * Moves all shutters of the desired floor(s) to the desired position
+     * @param c - the command to be executed on all windows of the desired floor(s)
+     */
+    static setAllShutterOfFloor(c) {
+        var _a;
+        const rooms = c.specificFloor != undefined ? this.getAllRoomsOfFloor(c.specificFloor) : this.Rooms.entries();
+        for (const [_name, room] of rooms) {
+            (_a = room.WindowGroup) === null || _a === void 0 ? void 0 : _a.setDesiredPosition(new command_1.WindowSetDesiredPositionCommand(c, c.position));
+        }
+    }
+    /**
+     * Set ALl Lamps of a specific floor
+     * !!floor -1 sets all lamps in house instead!!
+     * @param floor - {number} the level on which all lamps shall be changed -1 equals all rooms
+     * @param command - {ActuatorSetStateCommand} the command to be executed
+     */
+    static setAllLampsOfFloor(floor, command) {
+        var _a, _b, _c, _d;
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Schalte alle Lampen in Etage ${floor} auf den Wert ${command.on}`);
+        const rooms = floor > -1 ? this.getAllRoomsOfFloor(floor) : this.Rooms.entries();
+        for (const [_name, room] of rooms) {
+            (_a = room.LightGroup) === null || _a === void 0 ? void 0 : _a.setAllLampen(command);
+            (_b = room.LightGroup) === null || _b === void 0 ? void 0 : _b.setAllLED(new command_1.LedSetLightCommand(command, command.on));
+            (_c = room.LightGroup) === null || _c === void 0 ? void 0 : _c.setAllOutlets(command);
+            (_d = room.LightGroup) === null || _d === void 0 ? void 0 : _d.setAllWled(new command_1.WledSetLightCommand(command, command.on));
+        }
+    }
+    static clearAllAlarms() {
+        for (const r of RoomService.Rooms.values()) {
+            if (r.WaterGroup) {
+                r.WaterGroup.stopAlarm();
+            }
+            if (r.SmokeGroup) {
+                r.SmokeGroup.stopAlarm();
+            }
+        }
+        this.stopIntrusionAlarm();
+    }
+    static startAwayMode() {
+        Sonos_1.SonosService.speakOnAll(i18n_1.Res.alarmArmed(), 40);
+        if (this._awayModeTimeout) {
+            clearTimeout(this._awayModeTimeout);
+        }
+        this._awayModeTimeout = utils_1.Utils.guardedTimeout(() => {
+            this.awayModeActive = true;
+            this._awayModeTimeout = undefined;
+            Telegram_1.TelegramService.inform('Alarm ist nun scharf. Gute Reise!');
+        }, 60000, this);
+    }
+    static startNightAlarmMode() {
+        Sonos_1.SonosService.speakOnAll(i18n_1.Res.alarmNightModeArmed(), 30);
+        if (this._nightModeTimeout) {
+            clearTimeout(this._nightModeTimeout);
+        }
+        this._nightModeTimeout = utils_1.Utils.guardedTimeout(() => {
+            this.nightAlarmActive = true;
+            this._nightModeTimeout = undefined;
+            Telegram_1.TelegramService.inform('Alarm ist nun scharf. Süße Träume!');
+        }, 60000, this);
+    }
+    static startIntrusionAlarm(room, device) {
+        const message = `!Potenzieller Eindringling! Bewegung in ${room.roomName} von ${device.info.fullName} festgestellt`;
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, message);
+        if (!this.awayModeActive && !this.nightAlarmActive) {
+            this.stopIntrusionAlarm();
+            return;
+        }
+        utils_1.Utils.guardedNewThread(() => {
+            Telegram_1.TelegramService.inform(message);
+        }, this);
+        if (this._intrusionAlarmActive) {
+            return;
+        }
+        this._intrusionAlarmActive = true;
+        this.performNextIntrusionLevel();
+    }
+    static endAlarmModes() {
+        if (this.awayModeActive) {
+            Telegram_1.TelegramService.sendMessageToSubscriber('Alarm Mode disarmed');
+            Sonos_1.SonosService.speakOnAll(i18n_1.Res.welcomeHome(), 35);
+        }
+        if (this.nightAlarmActive) {
+            Telegram_1.TelegramService.sendMessageToSubscriber('Nachtmodus der Alarmanlage entschärft');
+            Sonos_1.SonosService.speakOnAll(i18n_1.Res.goodMorning(), 30);
+        }
+        if (this._nightModeTimeout) {
+            clearTimeout(this._nightModeTimeout);
+        }
+        if (this._awayModeTimeout) {
+            clearTimeout(this._awayModeTimeout);
+        }
+        this.awayModeActive = false;
+        this.nightAlarmActive = false;
+        this.stopIntrusionAlarm();
+    }
+    static getLastMovements() {
+        return this.movementHistory.readAmount(15).join('\n');
+    }
+    static stopIntrusionAlarm() {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'Stoppe Intrusion Alarm');
+        if (this._intrusionAlarmTimeout) {
+            clearTimeout(this._intrusionAlarmTimeout);
+        }
+        if (!this._intrusionAlarmActive) {
+            return;
+        }
+        this._intrusionAlarmActive = false;
+        this._intrusionAlarmLevel = 0;
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Alert, 'Alarm wurde beendet --> Fahre Rollos in Ausgangsposition.');
+        this.restoreShutterPositions(new command_1.RoomRestoreShutterPositionCommand(enums_1.CommandSource.Force, false, 'Resetting all shutter in all Rooms to last known position'));
+        this.restoreLight(new command_1.RoomRestoreLightCommand(enums_1.CommandSource.Force, 'roomService.clearAllAlarms'));
+    }
+    static performNextIntrusionLevel() {
+        this._intrusionAlarmTimeout = undefined;
+        if (!this.awayModeActive && !this._intrusionAlarmActive) {
+            return;
+        }
+        this._intrusionAlarmLevel += 1;
+        let speakMessage;
+        let volume = 50;
+        let newTimeout = 20000;
+        const alarmAutomaticEnd = 15;
+        if (this._intrusionAlarmLevel === 1) {
+            speakMessage = i18n_1.Res.intruderGreeting();
+            volume = 40;
+        }
+        else if (this._intrusionAlarmLevel === 2) {
+            speakMessage = i18n_1.Res.intruderShutterUpPleaseLeave();
+            utils_1.Utils.guardedNewThread(() => {
+                this.setAllShutterOfFloor(new command_1.FloorSetAllShuttersCommand(enums_1.CommandSource.Automatic, 100, undefined, 'Intrusion alarm level 2'));
+                this.setAllLampsOfFloor(-1, new command_1.ActuatorSetStateCommand(enums_1.CommandSource.Automatic, true, 'Intrusion alarm level 2'));
+            }, this);
+        }
+        else if (this._intrusionAlarmLevel === 3) {
+            volume = 70;
+            speakMessage = i18n_1.Res.intruderLeaveAndOwnerInformed();
+        }
+        else if (this._intrusionAlarmLevel <= 5) {
+            volume = 80;
+            speakMessage = i18n_1.Res.intruderAdditionalDefenseWarning();
+        }
+        else if (this._intrusionAlarmLevel >= alarmAutomaticEnd) {
+            this.stopIntrusionAlarm();
+            return;
+        }
+        else {
+            volume = 90;
+            speakMessage = i18n_1.Res.intruderAlarm();
+            newTimeout = 10000;
+        }
+        this._intrusionAlarmTimeout = utils_1.Utils.guardedTimeout(() => {
+            this.performNextIntrusionLevel();
+        }, newTimeout, this);
+        utils_1.Utils.guardedNewThread(() => {
+            Sonos_1.SonosService.speakOnAll(speakMessage, volume);
+            Telegram_1.TelegramService.inform(`Eindringling erhielt folgende Nachricht: "${speakMessage}"\nAlarmlevel ist ${this._intrusionAlarmLevel}\t Automatisches Ende bei ${alarmAutomaticEnd}`);
+        }, this);
+    }
+    static restoreShutterPositions(c) {
+        var _a;
+        for (const room of this.Rooms.values()) {
+            (_a = room.WindowGroup) === null || _a === void 0 ? void 0 : _a.restoreShutterPosition(c);
+        }
+    }
+    static restoreLight(c) {
+        for (const room of this.Rooms.values()) {
+            room.setLightTimeBased(new command_1.RoomSetLightTimeBasedCommand(c, true, 'roomService.restoreLight'));
+        }
+    }
+}
+exports.RoomService = RoomService;
+/**
+ * A Map containing all rooms in the house identified by their name
+ */
+RoomService.Rooms = new Map();
+/**
+ * A Map containing all groups in the house identified by {@link BaseGroup.id}
+ */
+RoomService.Groups = new Map();
+/**
+ * A boolean indicating if the away mode is active, which triggers certain alarms on movement
+ */
+RoomService.awayModeActive = false;
+/**
+ * A boolean indicating if the night mode is active, which triggers certain alarms on movement in rooms included in night alarm
+ */
+RoomService.nightAlarmActive = false;
+/**
+ * A ring storage containing the last 15 detected movements in the house
+ */
+RoomService.movementHistory = new utils_1.RingStorage(15);
+RoomService._intrusionAlarmActive = false;
+RoomService._intrusionAlarmLevel = 0;

package/lib/services/tibber-service.d.ts

@@ -0,0 +1,13 @@
+import { TibberFeed, TibberQueryBase } from 'tibber-api';
+import { iTibberSettings } from '../interfaces';
+export declare class TibberService {
+    private static _tibberQueryBase;
+    static get tibberQueryBase(): TibberQueryBase;
+    private static _tibberFeed;
+    static get tibberFeed(): TibberFeed;
+    private static _settings;
+    static get settings(): iTibberSettings | undefined;
+    private static _active;
+    static get active(): boolean;
+    static initialize(settings?: iTibberSettings): void;
+}

package/lib/services/time-callback-service.d.ts

@@ -0,0 +1,28 @@
+import { TimeOfDay } from '../enums';
+import { TimeCallback } from '../models';
+import { iSunTimeOffsets, ITimeCallback } from '../interfaces';
+export declare class TimeCallbackService {
+    private static _startTime;
+    private static _todaySunRise;
+    private static _todaySunSet;
+    private static _callbacks;
+    private static _iCheckTimeout;
+    private static _lastCheck;
+    private static _nextSunRise;
+    static get startTime(): Date;
+    static get nextSunRise(): Date;
+    private static _nextSunSet;
+    static get nextSunSet(): Date;
+    static dayType(pOffset: iSunTimeOffsets, now?: Date): TimeOfDay;
+    static darkOutsideOrNight(dayType: TimeOfDay): boolean;
+    static stopInterval(): void;
+    static init(startTime?: Date): void;
+    static addCallback(pCallback: TimeCallback): void;
+    static performCheck(): void;
+    static recalcSunTimes(calculationDate?: Date): void;
+    static removeCallback(pCallback: ITimeCallback): void;
+    static updateSunRise(pDay?: Date, lat?: number, long?: number): void;
+    static updateSunSet(pDay?: Date, lat?: number, long?: number): void;
+    static getSunsetForDate(pDay?: Date, lat?: number, long?: number): Date;
+    static hoursTilSunset(): number;
+}

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

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeCallbackService = void 0;
+const enums_1 = require("../enums");
+const models_1 = require("../models");
+const settings_service_1 = require("../settings-service");
+const logging_1 = require("../logging");
+const devices_1 = require("../devices");
+const utils_1 = require("../utils");
+const sunrise_sunset_js_1 = require("sunrise-sunset-js");
+class TimeCallbackService {
+    static get startTime() {
+        return this._startTime;
+    }
+    static get nextSunRise() {
+        return TimeCallbackService._nextSunRise;
+    }
+    static get nextSunSet() {
+        return TimeCallbackService._nextSunSet;
+    }
+    static dayType(pOffset, 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 enums_1.TimeOfDay.Night;
+            }
+        }
+        else {
+            if (hours > nightStart.hours ||
+                hours < nightEnd.hours ||
+                (hours === nightStart.hours && minutes >= nightStart.minutes) ||
+                (hours === nightEnd.hours && minutes <= nightEnd.minutes)) {
+                return enums_1.TimeOfDay.Night;
+            }
+        }
+        let sunset = new Date(TimeCallbackService._todaySunSet.getTime() + pOffset.sunset * 60 * 1000);
+        const maximumSunset = pOffset.getNextMaximumSunset(now);
+        if (maximumSunset.getDate() !== sunset.getDate()) {
+            maximumSunset.setDate(maximumSunset.getDate() - 1);
+        }
+        if (maximumSunset < sunset && maximumSunset.getDate() === sunset.getDate()) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, `Maximum Sunset vor nächstem Sunset: Sunset ${sunset.toLocaleString()}\t\t${maximumSunset.toLocaleString()}`);
+            sunset = maximumSunset;
+        }
+        if (now > sunset) {
+            return enums_1.TimeOfDay.AfterSunset;
+        }
+        const minimumSunrise = pOffset.getNextMinimumSunrise(now);
+        let sunrise = new Date(TimeCallbackService._todaySunRise.getTime() + pOffset.sunrise * 60 * 1000);
+        if (minimumSunrise.getDate() !== sunrise.getDate()) {
+            minimumSunrise.setDate(minimumSunrise.getDate() - 1);
+        }
+        if (minimumSunrise > sunrise && minimumSunrise.getDate() === sunrise.getDate()) {
+            logging_1.ServerLogService.writeLog(enums_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 enums_1.TimeOfDay.BeforeSunrise;
+        }
+        return enums_1.TimeOfDay.Daylight;
+    }
+    static darkOutsideOrNight(dayType) {
+        switch (dayType) {
+            case enums_1.TimeOfDay.Night:
+            case enums_1.TimeOfDay.BeforeSunrise:
+            case enums_1.TimeOfDay.AfterSunset:
+                return true;
+            default:
+                return false;
+        }
+    }
+    static stopInterval() {
+        if (this._iCheckTimeout !== undefined) {
+            clearInterval(this._iCheckTimeout);
+            this._iCheckTimeout = undefined;
+        }
+    }
+    static init(startTime = new Date()) {
+        this._startTime = startTime;
+        const dailyRecalc = new models_1.TimeCallback('Midnight Recalc', enums_1.TimeCallbackType.TimeOfDay, () => {
+            TimeCallbackService.recalcSunTimes();
+            devices_1.Devices.midnightReset();
+        }, 0, 0, 0);
+        const daily3oClockRecalc = new models_1.TimeCallback('Daily3oClockRecalc', enums_1.TimeCallbackType.TimeOfDay, () => {
+            devices_1.Devices.resetDetectionsToday();
+        }, 0, 3, 0);
+        TimeCallbackService.recalcSunTimes();
+        TimeCallbackService.addCallback(dailyRecalc);
+        TimeCallbackService.addCallback(daily3oClockRecalc);
+        this._iCheckTimeout = utils_1.Utils.guardedInterval(TimeCallbackService.performCheck.bind(this), 60000);
+    }
+    static addCallback(pCallback) {
+        if (TimeCallbackService._callbacks.has(pCallback.name)) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Overwriting existing TimeCallback "${pCallback.name}"`);
+        }
+        TimeCallbackService._callbacks.set(pCallback.name, pCallback);
+    }
+    static performCheck() {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Trace, 'Perform TimeCallBackCheck');
+        const now = new Date();
+        for (const tc of TimeCallbackService._callbacks.values()) {
+            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.perform(now);
+            }
+        }
+        if (TimeCallbackService._nextSunRise < now) {
+            const tomorrow = new Date(new Date().setHours(2, 0, 0, 0) + 24 * 60 * 60 * 1000);
+            TimeCallbackService.updateSunRise(tomorrow);
+        }
+        if (TimeCallbackService._nextSunSet < now) {
+            const tomorrow = new Date(new Date().setHours(2, 0, 0, 0) + 24 * 60 * 60 * 1000);
+            TimeCallbackService.updateSunSet(tomorrow);
+        }
+        TimeCallbackService._lastCheck = now;
+    }
+    static recalcSunTimes(calculationDate = new Date()) {
+        TimeCallbackService._todaySunRise = (0, sunrise_sunset_js_1.getSunrise)(settings_service_1.SettingsService.latitude, settings_service_1.SettingsService.longitude, calculationDate);
+        TimeCallbackService._todaySunSet = (0, sunrise_sunset_js_1.getSunset)(settings_service_1.SettingsService.latitude, settings_service_1.SettingsService.longitude, calculationDate);
+        TimeCallbackService.updateSunSet();
+        TimeCallbackService.updateSunRise();
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Today Sunrise: ${TimeCallbackService._todaySunRise.toLocaleString('de-DE')}
+Today Sunset: ${TimeCallbackService._todaySunSet.toLocaleString('de-DE')}
+Next Sunrise: ${TimeCallbackService._nextSunRise.toLocaleString('de-DE')}
+Next Sunset: ${TimeCallbackService._nextSunSet.toLocaleString('de-DE')}`);
+    }
+    static removeCallback(pCallback) {
+        if (TimeCallbackService._callbacks.has(pCallback.name)) {
+            TimeCallbackService._callbacks.delete(pCallback.name);
+        }
+        else {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `TimeCallback to remove ("${pCallback.name}") doesn't exist.`);
+        }
+    }
+    static updateSunRise(pDay = new Date(), lat, long) {
+        TimeCallbackService._nextSunRise = (0, sunrise_sunset_js_1.getSunrise)(lat !== null && lat !== void 0 ? lat : settings_service_1.SettingsService.latitude, long !== null && long !== void 0 ? long : settings_service_1.SettingsService.longitude, pDay);
+    }
+    static updateSunSet(pDay = new Date(), lat, long) {
+        TimeCallbackService._nextSunSet = this.getSunsetForDate(pDay, lat !== null && lat !== void 0 ? lat : settings_service_1.SettingsService.latitude, long !== null && long !== void 0 ? long : settings_service_1.SettingsService.longitude);
+    }
+    static getSunsetForDate(pDay = new Date(), lat, long) {
+        return (0, sunrise_sunset_js_1.getSunset)(lat !== null && lat !== void 0 ? lat : settings_service_1.SettingsService.latitude, long !== null && long !== void 0 ? long : settings_service_1.SettingsService.longitude, pDay);
+    }
+    static hoursTilSunset() {
+        return (this.nextSunSet.getTime() - utils_1.Utils.nowMS()) / 1000 / 60;
+    }
+}
+exports.TimeCallbackService = TimeCallbackService;
+TimeCallbackService._callbacks = new Map();
+TimeCallbackService._lastCheck = new Date(0);

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

@@ -0,0 +1,2 @@
+export * from './weather-service';
+export { RainNextMinutesInfo } from './rain-next-minutes-info';

package/lib/services/weather/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
+exports.RainNextMinutesInfo = void 0;
+__exportStar(require("./weather-service"), 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/services/weather/weather-service.d.ts

@@ -0,0 +1,47 @@
+import { iSpeaker, iWeatherSettings, WeatherResponse } from '../../interfaces';
+import { LogDebugType, LogLevel } from '../../enums';
+import { ShutterSettings } from '../../devices';
+export declare class WeatherService {
+    /**
+     * Whether the service is active or not
+     */
+    static active: boolean;
+    /**
+     * The milliseconds of one day
+     */
+    static readonly oneDay: number;
+    /**
+     * The last weather response
+     */
+    static lastResponse: WeatherResponse | undefined;
+    /**
+     * The sun horizontal degree (0 is North)
+     */
+    static sunDirection: number;
+    private static _dataUpdateCbs;
+    private static _refreshInterval;
+    private static latitude;
+    private static longitude;
+    private static appID?;
+    static addWeatherUpdateCb(name: string, cb: () => void): void;
+    static get todayMaxTemp(): number;
+    static initialize(config: iWeatherSettings): void;
+    static update(): void;
+    static stopInterval(): void;
+    static playWeatherInfo(speaker: iSpeaker, volume?: number, short?: boolean, retries?: number): void;
+    static processHourlyWeather(response: WeatherResponse): void;
+    static get currentHumidity(): number;
+    static get currentTemp(): number;
+    static willOutsideBeWarmer(referenceTemperature: number, logger: (level: LogLevel, message: string, debugType?: LogDebugType) => void): boolean;
+    static weatherRolloPosition(normalPos: number, desiredTemperatur: number, currentTemperatur: number, logger: (level: LogLevel, message: string, debugType?: LogDebugType) => void, shutterSettings: ShutterSettings): number;
+    static getCurrentCloudiness(): number;
+    private static getRainNextMinutes;
+    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;
+}