hoffmation-base 3.0.2 → 3.1.0

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

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeatherService = void 0;
+const suncalc_1 = __importDefault(require("suncalc"));
+const time_callback_service_1 = require("../time-callback-service");
+const interfaces_1 = require("../../interfaces");
+const utils_1 = require("../../utils");
+const enums_1 = require("../../enums");
+const logging_1 = require("../../logging");
+const HTTPSOptions_1 = require("../HTTPSOptions");
+const https_service_1 = require("../https-service");
+class WeatherService {
+    static addWeatherUpdateCb(name, cb) {
+        this._dataUpdateCbs[name] = cb;
+    }
+    static get todayMaxTemp() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = WeatherService.lastResponse) === null || _a === void 0 ? void 0 : _a.daily[0]) === null || _b === void 0 ? void 0 : _b.temp.max) !== null && _c !== void 0 ? _c : interfaces_1.UNDEFINED_TEMP_VALUE;
+    }
+    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.update, 10 * 60 * 1000, WeatherService, true);
+    }
+    static update() {
+        this.recalcAzimuth();
+        this.getWeatherData();
+    }
+    static stopInterval() {
+        if (this._refreshInterval !== undefined) {
+            clearInterval(this._refreshInterval);
+            this._refreshInterval = undefined;
+        }
+    }
+    static playWeatherInfo(speaker, volume = 30, short = false, retries = 5) {
+        const wData = WeatherService.lastResponse;
+        if (wData === undefined) {
+            if (retries > 0) {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, 'WeatherService.playWeatherInfo(): Der Wetterbericht ist noch nicht bereit --> warten');
+                setTimeout(() => {
+                    WeatherService.playWeatherInfo(speaker, volume, short, retries - 1);
+                }, 1000);
+            }
+            else {
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, 'WeatherService.playWeatherInfo(): Der Wetterbericht ist vorhanden --> Abbruch');
+            }
+            return;
+        }
+        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) {
+            speaker.speakOnDevice(`Heute sollen es im Durchschnitt ${Math.round(wData.daily[0].temp.day)} Grad sein.`, volume, false);
+            speaker.speakOnDevice(`Die Höchsttemperatur liegt heute bei ${Math.round(wData.daily[0].temp.max)} Grad.`, volume, false);
+            speaker.speakOnDevice(`Die Tiefsttemperatur soll heute ${Math.round(wData.daily[0].temp.min)} Grad betragen.`, volume, false);
+            if (wData.daily[0].rain !== undefined) {
+                speaker.speakOnDevice(`Es sollen heute etwa ${Math.round(wData.daily[0].rain)} Millimeter Regen fallen.`, volume, false);
+            }
+        }
+        if (wData.daily[0].snow !== undefined && wData.daily[0].snow > 0) {
+            speaker.speakOnDevice(`Heute wird es Schneien! Es werden etwa ${Math.round(wData.daily[0].snow)} Millimeter Schnee erwartet.`, 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;
+        }
+        speaker.speakOnDevice(message, volume, false);
+        if (!short && precipitation > 0) {
+            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:'];
+            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}`)
+            });
+            speaker.speakOnDevice(alertMessage.join('\n'), volume, false);
+        }
+        else if (!short) {
+            speaker.speakOnDevice('Für heute liegt keine Unwetterwarnungen vor', volume, false);
+        }
+    }
+    static processHourlyWeather(response) {
+        this.lastResponse = response;
+        logging_1.ServerLogService.writeLog(enums_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}`);
+            });
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, message.join('\n'));
+        }
+    }
+    static get currentHumidity() {
+        var _a;
+        if (((_a = WeatherService.lastResponse) === null || _a === void 0 ? void 0 : _a.current) === undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'WeatherService.currentHumidity: There is no data yet');
+            return -1;
+        }
+        return WeatherService.lastResponse.current.humidity;
+    }
+    static get currentTemp() {
+        var _a;
+        if (((_a = WeatherService.lastResponse) === null || _a === void 0 ? void 0 : _a.current) === undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'WeatherService.isOutsideWarmer(): There are no data yet');
+            return -99;
+        }
+        return WeatherService.lastResponse.current.temp;
+    }
+    static willOutsideBeWarmer(referenceTemperature, logger) {
+        const wData = WeatherService.lastResponse;
+        if (wData === undefined || wData.current === undefined) {
+            logger(enums_1.LogLevel.Info, 'WeatherService.isOutsideWarmer(): There are no data yet');
+            return false;
+        }
+        logger(enums_1.LogLevel.Info, `willOutsideBeWarmer(${referenceTemperature}) --> Today Max Temperature: ${wData.daily[0].temp.max}`);
+        return referenceTemperature < wData.daily[0].temp.max;
+    }
+    static weatherRolloPosition(normalPos, desiredTemperatur, currentTemperatur, logger, shutterSettings) {
+        let result = normalPos;
+        if (currentTemperatur < desiredTemperatur) {
+            logger(enums_1.LogLevel.Trace, 'RolloWeatherPosition: Room needs to heat up anyways.');
+            return result;
+        }
+        else if (normalPos < 30) {
+            logger(enums_1.LogLevel.Trace, 'RolloWeatherPosition: Shutter should be down anyways.');
+            return result;
+        }
+        else if (this.hoursTilSunset() < 1) {
+            logger(enums_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(enums_1.LogLevel.Trace, 'RolloWeatherPosition: Sun is facing a different direction');
+            return result;
+        }
+        else if (this.getCurrentCloudiness() > 40) {
+            logger(enums_1.LogLevel.Trace, 'RolloWeatherPosition: It´s cloudy now.');
+        }
+        else if (this.willOutsideBeWarmer(26, logger)) {
+            result = shutterSettings.heatReductionPosition;
+        }
+        if (result !== normalPos) {
+            logger(enums_1.LogLevel.Info, `weatherRolloPosition(${normalPos}, ${desiredTemperatur}, ${currentTemperatur}) --> Target: ${result}`);
+        }
+        return result;
+    }
+    static getCurrentCloudiness() {
+        const wData = WeatherService.lastResponse;
+        if (wData === undefined || wData.current === undefined) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, 'WeatherService.getCurrentCloudiness(): There are no data yet');
+            return 0;
+        }
+        return wData.current.clouds;
+    }
+    static getRainNextMinutes() {
+        var _a;
+        const minutes = (_a = WeatherService.lastResponse) === null || _a === void 0 ? void 0 : _a.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() {
+        var _a;
+        const result = [];
+        if (((_a = WeatherService.lastResponse) === null || _a === void 0 ? void 0 : _a.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() {
+        if (!this.appID) {
+            return;
+        }
+        const host = 'api.openweathermap.org';
+        const path = `/data/3.0/onecall?lat=${WeatherService.latitude}&lon=${WeatherService.longitude}&appid=${WeatherService.appID}&units=metric&lang=de`;
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, 'Send WeatherAPi Request for data update.');
+        https_service_1.HTTPSService.request(new HTTPSOptions_1.HTTPSOptions(host, path, {}, 'GET', 443), '', 5, (response) => {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, 'WeatherAPi Response erhalten');
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.DeepTrace, `WeatherAPi Response: ${response}`);
+            utils_1.Utils.guardedFunction(() => {
+                const responseObj = JSON.parse(response);
+                WeatherService.processHourlyWeather(responseObj);
+                for (const dataUpdateCbsKey in this._dataUpdateCbs) {
+                    this._dataUpdateCbs[dataUpdateCbsKey]();
+                }
+            }, this, `Response from Weather API call at https://${host}/${path}: ${response}`);
+        });
+    }
+    static recalcAzimuth() {
+        this.sunDirection =
+            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));
+        return (sunset.getTime() - now.getTime()) / (1000 * 60 * 60);
+    }
+}
+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 = {};

package/lib/settings-service-instance.d.ts

@@ -0,0 +1,12 @@
+import { iConfig, iSettingsProvider } from './interfaces';
+import { HeatingMode } from './enums';
+export declare class SettingsServiceInstance implements iSettingsProvider {
+    settings: iConfig;
+    constructor(settings: iConfig);
+    get TelegramActive(): boolean;
+    get Mp3Active(): boolean;
+    get heatMode(): HeatingMode;
+    get latitude(): number;
+    get longitude(): number;
+    initialize(config: iConfig): void;
+}

package/lib/settings-service-instance.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsServiceInstance = void 0;
+const enums_1 = require("./enums");
+const command_1 = require("./command");
+class SettingsServiceInstance {
+    constructor(settings) {
+        var _a, _b, _c;
+        this.settings = settings;
+        command_1.BlockAutomaticCommand.defaultDefaultCollisionSolving =
+            (_a = settings.blockAutomaticHandlerDefaults) === null || _a === void 0 ? void 0 : _a.defaultCollisionSolving;
+        command_1.BlockAutomaticCommand.defaultBlockAutomaticDurationMS =
+            (_b = settings.blockAutomaticHandlerDefaults) === null || _b === void 0 ? void 0 : _b.blockAutomaticDurationMS;
+        command_1.BlockAutomaticCommand.defaultRevertToAutomaticAtBlockLift =
+            (_c = settings.blockAutomaticHandlerDefaults) === null || _c === void 0 ? void 0 : _c.revertToAutomaticAtBlockLift;
+    }
+    get TelegramActive() {
+        return this.settings.telegram !== undefined;
+    }
+    get Mp3Active() {
+        return this.settings.mp3Server !== undefined;
+    }
+    get heatMode() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.settings) === null || _a === void 0 ? void 0 : _a.heaterSettings) === null || _b === void 0 ? void 0 : _b.mode) !== null && _c !== void 0 ? _c : enums_1.HeatingMode.None;
+    }
+    get latitude() {
+        var _a, _b;
+        if (((_b = (_a = this.settings) === null || _a === void 0 ? void 0 : _a.weather) === null || _b === void 0 ? void 0 : _b.lattitude) !== undefined) {
+            const lat = parseFloat(this.settings.weather.lattitude);
+            if (!Number.isNaN(lat)) {
+                return lat;
+            }
+        }
+        return 51.529556852253826;
+    }
+    get longitude() {
+        var _a, _b;
+        if (((_b = (_a = this.settings) === null || _a === void 0 ? void 0 : _a.weather) === null || _b === void 0 ? void 0 : _b.longitude) !== undefined) {
+            const longitude = parseFloat(this.settings.weather.longitude);
+            if (!Number.isNaN(longitude)) {
+                return longitude;
+            }
+        }
+        return 7.097266042276687;
+    }
+    initialize(config) {
+        this.settings = config;
+    }
+}
+exports.SettingsServiceInstance = SettingsServiceInstance;

package/lib/settings-service.d.ts

@@ -0,0 +1,22 @@
+import { HeatingMode } from './enums';
+import { iConfig, iSettingsProvider } from './interfaces';
+export declare class SettingsService {
+    private static _instance;
+    static get instance(): iSettingsProvider;
+    /**
+     * The active settings for the Hoffmation system.
+     */
+    static settings: iConfig;
+    static get TelegramActive(): boolean;
+    static get Mp3Active(): boolean;
+    static get heatMode(): HeatingMode;
+    static get latitude(): number;
+    static get longitude(): number;
+    static initialize(config: iConfig): void;
+    /**
+     * Generates a fresh Test configuration.
+     * @returns The test configuration.
+     * @deprecated Only use in unit tests.
+     */
+    static get testConfig(): iConfig;
+}

package/lib/settings-service.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsService = void 0;
+const settings_service_instance_1 = require("./settings-service-instance");
+class SettingsService {
+    static get instance() {
+        var _a;
+        (_a = this._instance) !== null && _a !== void 0 ? _a : (this._instance = new settings_service_instance_1.SettingsServiceInstance(this.settings));
+        return this._instance;
+    }
+    static get TelegramActive() {
+        return this.instance.TelegramActive;
+    }
+    static get Mp3Active() {
+        return this.instance.Mp3Active;
+    }
+    static get heatMode() {
+        return this.instance.heatMode;
+    }
+    static get latitude() {
+        return this.instance.latitude;
+    }
+    static get longitude() {
+        return this.instance.longitude;
+    }
+    static initialize(config) {
+        this.settings = config;
+        this._instance = new settings_service_instance_1.SettingsServiceInstance(config);
+    }
+    /**
+     * Generates a fresh Test configuration.
+     * @returns The test configuration.
+     * @deprecated Only use in unit tests.
+     */
+    static get testConfig() {
+        return {
+            roomDefault: {
+                rolloHeatReduction: true,
+                roomIsAlwaysDark: false,
+                lampenBeiBewegung: true,
+                lichtSonnenAufgangAus: true,
+                sonnenUntergangRollos: true,
+                sonnenAufgangRollos: true,
+                movementResetTimer: 240,
+                sonnenUntergangRolloDelay: 15,
+                sonnenUntergangLampenDelay: 15,
+                sonnenUntergangRolloMaxTime: {
+                    hours: 21,
+                    minutes: 30,
+                },
+                sonnenAufgangRolloMinTime: {
+                    hours: 7,
+                    minutes: 30,
+                },
+                sonnenAufgangRolloDelay: 35,
+                sonnenAufgangLampenDelay: 15,
+                sonnenUntergangRolloAdditionalOffsetPerCloudiness: 0.25,
+                lightIfNoWindows: false,
+                ambientLightAfterSunset: false,
+                includeLampsInNormalMovementLightning: false,
+            },
+            timeSettings: {
+                nightStart: {
+                    hours: 23,
+                    minutes: 45,
+                },
+                nightEnd: {
+                    hours: 6,
+                    minutes: 30,
+                },
+            },
+            translationSettings: {
+                language: 'en',
+            },
+            ioBrokerUrl: '',
+        };
+    }
+}
+exports.SettingsService = SettingsService;

package/lib/settingsObjects/blockAutomaticSettings.d.ts

@@ -0,0 +1,24 @@
+import { CollisionSolving } from '../enums';
+import { iBlockAutomaticSettings } from '../interfaces';
+export declare class BlockAutomaticSettings implements iBlockAutomaticSettings {
+    /**
+     * The duration in ms at which the automatic block should be disabled on force actions.
+     * If not set {@link iBlockAutomaticHandlerDefaults.blockAutomaticDurationMS} will be used.
+     */
+    blockAutomaticDurationMS?: number;
+    /**
+     * If set to true, the automatic won't be blocked on force Action (unless explicitly provided).
+     */
+    dontBlockAutomaticIfNotProvided?: boolean;
+    /**
+     * The collision solving strategy to use
+     * If not set {@link iBlockAutomaticHandlerDefaults.defaultCollisionSolving} will be used.
+     */
+    defaultCollisionSolving?: CollisionSolving;
+    /**
+     * If set to true, the automatic will be reverted to the automatic state when the block is lifted.
+     * If not set {@link iBlockAutomaticHandlerDefaults.revertToAutomaticAtBlockLift} will be used.
+     */
+    revertToAutomaticAtBlockLift?: boolean;
+    fromPartialObject(obj: Partial<BlockAutomaticSettings>): void;
+}

package/lib/settingsObjects/deviceSettings/acSettings.d.ts

@@ -0,0 +1,49 @@
+import { iAcSettings, iExcessEnergyConsumerSettings } from '../../interfaces';
+import { DeviceSettings } from './deviceSettings';
+export declare class AcSettings extends DeviceSettings implements iAcSettings {
+    /** The energy consumer settings for this AC */
+    energySettings: iExcessEnergyConsumerSettings;
+    /**
+     * The earliest hour the AC can be turned on
+     */
+    minimumHours: number;
+    /**
+     * The earliest minute the AC can be turned on within the hour {@link minimumHours}
+     */
+    minimumMinutes: number;
+    /**
+     * The latest hour the AC can be turned on
+     */
+    maximumHours: number;
+    /**
+     * The latest minute the AC can be turned on within the hour {@link maximumHours}
+     */
+    maximumMinutes: number;
+    /**
+     * Heating can be forbidden completly e.g. for summer season
+     */
+    heatingAllowed: boolean;
+    /**
+     * Whether we should ignore the room temperature and let the AC decide on its own
+     */
+    useOwnTemperature: boolean;
+    /**
+     * Whether the AC should use automatic mode to decide on its own whether to heat or cool
+     * @warning This can result in excessive energy consumption, as overshooting the temperature can result in the AC switching to the opposite mode
+     */
+    useAutomatic: boolean;
+    /**
+     * Whether we should turn off AC-Cooling when someone is in the room
+     */
+    noCoolingOnMovement: boolean;
+    /**
+     * Whether this AC should be turned off for some time manually
+     */
+    manualDisabled: boolean;
+    /**
+     * The minimum outside temperature (max. of day)  in Celsius to even consider cooling.
+     */
+    minOutdoorTempForCooling: number;
+    fromPartialObject(data: Partial<AcSettings>): void;
+    toJSON(): Partial<AcSettings>;
+}

package/lib/settingsObjects/deviceSettings/acSettings.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcSettings = void 0;
+const settingsObjects_1 = require("../../settingsObjects");
+const utils_1 = require("../../utils");
+const deviceSettings_1 = require("./deviceSettings");
+class AcSettings extends deviceSettings_1.DeviceSettings {
+    constructor() {
+        super(...arguments);
+        /** The energy consumer settings for this AC */
+        this.energySettings = new settingsObjects_1.ExcessEnergyConsumerSettings();
+        /**
+         * The earliest hour the AC can be turned on
+         */
+        this.minimumHours = 0;
+        /**
+         * The earliest minute the AC can be turned on within the hour {@link minimumHours}
+         */
+        this.minimumMinutes = 0;
+        /**
+         * The latest hour the AC can be turned on
+         */
+        this.maximumHours = 24;
+        /**
+         * The latest minute the AC can be turned on within the hour {@link maximumHours}
+         */
+        this.maximumMinutes = 0;
+        /**
+         * Heating can be forbidden completly e.g. for summer season
+         */
+        this.heatingAllowed = false;
+        /**
+         * Whether we should ignore the room temperature and let the AC decide on its own
+         */
+        this.useOwnTemperature = false;
+        /**
+         * Whether the AC should use automatic mode to decide on its own whether to heat or cool
+         * @warning This can result in excessive energy consumption, as overshooting the temperature can result in the AC switching to the opposite mode
+         */
+        this.useAutomatic = false;
+        /**
+         * Whether we should turn off AC-Cooling when someone is in the room
+         */
+        this.noCoolingOnMovement = false;
+        /**
+         * Whether this AC should be turned off for some time manually
+         */
+        this.manualDisabled = false;
+        /**
+         * The minimum outside temperature (max. of day)  in Celsius to even consider cooling.
+         */
+        this.minOutdoorTempForCooling = 21;
+    }
+    fromPartialObject(data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.minimumHours = (_a = data.minimumHours) !== null && _a !== void 0 ? _a : this.minimumHours;
+        this.minimumMinutes = (_b = data.minimumMinutes) !== null && _b !== void 0 ? _b : this.minimumMinutes;
+        this.maximumHours = (_c = data.maximumHours) !== null && _c !== void 0 ? _c : this.maximumHours;
+        this.maximumMinutes = (_d = data.maximumMinutes) !== null && _d !== void 0 ? _d : this.maximumMinutes;
+        this.heatingAllowed = (_e = data.heatingAllowed) !== null && _e !== void 0 ? _e : this.heatingAllowed;
+        this.noCoolingOnMovement = (_f = data.noCoolingOnMovement) !== null && _f !== void 0 ? _f : this.noCoolingOnMovement;
+        this.useOwnTemperature = (_g = data.useOwnTemperature) !== null && _g !== void 0 ? _g : this.useOwnTemperature;
+        this.useAutomatic = (_h = data.useAutomatic) !== null && _h !== void 0 ? _h : this.useAutomatic;
+        this.manualDisabled = (_j = data.manualDisabled) !== null && _j !== void 0 ? _j : this.manualDisabled;
+        this.minOutdoorTempForCooling = (_k = data.minOutdoorTempForCooling) !== null && _k !== void 0 ? _k : this.minOutdoorTempForCooling;
+        super.fromPartialObject(data);
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this);
+    }
+}
+exports.AcSettings = AcSettings;

package/lib/settingsObjects/deviceSettings/actuatorSettings.d.ts

@@ -0,0 +1,40 @@
+import { iActuatorSettings } from '../../interfaces';
+import { DeviceSettings } from './deviceSettings';
+export declare class ActuatorSettings extends DeviceSettings implements iActuatorSettings {
+    /**
+     * Whether to turn on the device at dawn in time-based commands or automatic.
+     */
+    dawnOn: boolean;
+    /**
+     * Whether to turn on the device at dusk in time-based commands or automatic.
+     */
+    duskOn: boolean;
+    /**
+     * Whether to turn on the device at night in time-based commands or automatic.
+     */
+    nightOn: boolean;
+    /**
+     * Whether to turn on the device at day in time-based commands or automatic.
+     */
+    dayOn: boolean;
+    /**
+     * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
+     */
+    isStromStoss: boolean;
+    /**
+     * Whether after manually turning off a previously manually turned on device, fall back to automatic mode.
+     * Instead of switching to a forced off state.
+     */
+    resetToAutomaticOnForceOffAfterForceOn: boolean;
+    /**
+     * If this is an Actuator controling a time based relais,
+     * this indicates the time after which we retrigger the relais.
+     */
+    stromStossResendTime: number;
+    /**
+     * Whether to include this device in the ambient light option.
+     */
+    includeInAmbientLight: boolean;
+    fromPartialObject(data: Partial<ActuatorSettings>): void;
+    toJSON(): Partial<ActuatorSettings>;
+}

package/lib/settingsObjects/deviceSettings/actuatorSettings.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActuatorSettings = void 0;
+const deviceSettings_1 = require("./deviceSettings");
+const utils_1 = require("../../utils");
+class ActuatorSettings extends deviceSettings_1.DeviceSettings {
+    constructor() {
+        super(...arguments);
+        /**
+         * Whether to turn on the device at dawn in time-based commands or automatic.
+         */
+        this.dawnOn = true;
+        /**
+         * Whether to turn on the device at dusk in time-based commands or automatic.
+         */
+        this.duskOn = true;
+        /**
+         * Whether to turn on the device at night in time-based commands or automatic.
+         */
+        this.nightOn = true;
+        /**
+         * Whether to turn on the device at day in time-based commands or automatic.
+         */
+        this.dayOn = false;
+        /**
+         * Indicates if this device controls e.g. an Eltako, which has it's own Turn Off Time logic.
+         */
+        this.isStromStoss = false;
+        /**
+         * Whether after manually turning off a previously manually turned on device, fall back to automatic mode.
+         * Instead of switching to a forced off state.
+         */
+        this.resetToAutomaticOnForceOffAfterForceOn = true;
+        /**
+         * If this is an Actuator controling a time based relais,
+         * this indicates the time after which we retrigger the relais.
+         */
+        this.stromStossResendTime = 180;
+        /**
+         * Whether to include this device in the ambient light option.
+         */
+        this.includeInAmbientLight = false;
+    }
+    fromPartialObject(data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.dawnOn = (_a = data.dawnOn) !== null && _a !== void 0 ? _a : this.dawnOn;
+        this.duskOn = (_b = data.duskOn) !== null && _b !== void 0 ? _b : this.duskOn;
+        this.nightOn = (_c = data.nightOn) !== null && _c !== void 0 ? _c : this.nightOn;
+        this.dayOn = (_d = data.dayOn) !== null && _d !== void 0 ? _d : this.dayOn;
+        this.isStromStoss = (_e = data.isStromStoss) !== null && _e !== void 0 ? _e : this.isStromStoss;
+        this.stromStossResendTime = (_f = data.stromStossResendTime) !== null && _f !== void 0 ? _f : this.stromStossResendTime;
+        this.resetToAutomaticOnForceOffAfterForceOn =
+            (_g = data.resetToAutomaticOnForceOffAfterForceOn) !== null && _g !== void 0 ? _g : this.resetToAutomaticOnForceOffAfterForceOn;
+        this.includeInAmbientLight = (_h = data.includeInAmbientLight) !== null && _h !== void 0 ? _h : this.includeInAmbientLight;
+        super.fromPartialObject(data);
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this);
+    }
+}
+exports.ActuatorSettings = ActuatorSettings;