hoffmation-base 3.0.2 → 3.1.0

package/lib/devices/scene/room-scene.d.ts

@@ -0,0 +1,52 @@
+import { iRoomBase, iScene } from '../../interfaces';
+import { SceneSettings } from '../../settingsObjects';
+import { DeviceCapability, DeviceType, LogDebugType, LogLevel } from '../../enums';
+import { DeviceInfo } from '../DeviceInfo';
+import { TvDevice } from '../tv';
+export declare class RoomScene implements iScene {
+    /** @inheritDoc */
+    description: string;
+    /** @inheritDoc */
+    room: iRoomBase | undefined;
+    /** @inheritDoc */
+    settings: SceneSettings;
+    protected _deviceType: DeviceType;
+    protected _info: DeviceInfo;
+    private readonly _onSceneStart;
+    private readonly _onSceneEnd;
+    private _automaticEndTimeout;
+    private _deviceCapabilities;
+    private _on;
+    constructor(name: string, room: iRoomBase, onSceneStart: () => void, onSceneEnd: () => void, turnOffTimeout?: number);
+    /** @inheritDoc */
+    get customName(): string;
+    /** @inheritDoc */
+    get deviceType(): DeviceType;
+    /** @inheritDoc */
+    get info(): DeviceInfo;
+    /** @inheritDoc */
+    get automaticEndTimeout(): NodeJS.Timeout | null;
+    /** @inheritDoc */
+    get deviceCapabilities(): DeviceCapability[];
+    /** @inheritDoc */
+    get on(): boolean;
+    get name(): string;
+    /** @inheritDoc */
+    get id(): string;
+    /** @inheritDoc */
+    get onSceneEnd(): () => void;
+    /** @inheritDoc */
+    get onSceneStart(): () => void;
+    /** @inheritDoc */
+    startScene(timeout?: number | undefined): void;
+    /** @inheritDoc */
+    endScene(): void;
+    /** @inheritDoc */
+    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    /** @inheritDoc */
+    persistDeviceInfo(): void;
+    /** @inheritDoc */
+    loadDeviceSettings(): void;
+    /** @inheritDoc */
+    toJSON(): Partial<TvDevice>;
+}

package/lib/devices/scene/room-scene.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomScene = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const services_1 = require("../../services");
+const settingsObjects_1 = require("../../settingsObjects");
+const enums_1 = require("../../enums");
+const DeviceInfo_1 = require("../DeviceInfo");
+const devices_1 = require("../devices");
+const utils_1 = require("../../utils");
+const logging_1 = require("../../logging");
+class RoomScene {
+    constructor(name, room, onSceneStart, onSceneEnd, turnOffTimeout) {
+        /** @inheritDoc */
+        this.description = '';
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.SceneSettings();
+        this._automaticEndTimeout = null;
+        this._deviceCapabilities = [enums_1.DeviceCapability.scene];
+        this._on = false;
+        this._onSceneStart = onSceneStart;
+        this._onSceneEnd = onSceneEnd;
+        this.room = room;
+        this.settings.defaultTurnOffTimeout = turnOffTimeout;
+        this._info = new DeviceInfo_1.DeviceInfo();
+        this._info.fullName = `Scene ${name}`;
+        this._info.customName = `${room.roomName} ${name}`;
+        this._info.room = room.roomName;
+        this._info.allDevicesKey = `scene-${room.roomName}-${name}`;
+        this._deviceType = enums_1.DeviceType.RoomScene;
+        devices_1.Devices.alLDevices[this._info.allDevicesKey] = this;
+        this.persistDeviceInfo();
+        this.loadDeviceSettings();
+    }
+    /** @inheritDoc */
+    get customName() {
+        return this.info.customName;
+    }
+    /** @inheritDoc */
+    get deviceType() {
+        return this._deviceType;
+    }
+    /** @inheritDoc */
+    get info() {
+        return this._info;
+    }
+    /** @inheritDoc */
+    get automaticEndTimeout() {
+        return this._automaticEndTimeout;
+    }
+    /** @inheritDoc */
+    get deviceCapabilities() {
+        return this._deviceCapabilities;
+    }
+    /** @inheritDoc */
+    get on() {
+        return this._on;
+    }
+    get name() {
+        return this.info.customName;
+    }
+    /** @inheritDoc */
+    get id() {
+        var _a;
+        return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `ac-${this.info.room}-${this.info.customName}`;
+    }
+    /** @inheritDoc */
+    get onSceneEnd() {
+        return this._onSceneEnd;
+    }
+    /** @inheritDoc */
+    get onSceneStart() {
+        return this._onSceneStart;
+    }
+    /** @inheritDoc */
+    startScene(timeout) {
+        if (this._automaticEndTimeout != null) {
+            clearTimeout(this._automaticEndTimeout);
+            this._automaticEndTimeout = null;
+        }
+        this._on = true;
+        this._onSceneStart();
+        const turnOffTimeout = timeout !== null && timeout !== void 0 ? timeout : this.settings.defaultTurnOffTimeout;
+        this.log(enums_1.LogLevel.Info, `Starting scene (timeout: ${turnOffTimeout})`);
+        if (turnOffTimeout) {
+            this._automaticEndTimeout = utils_1.Utils.guardedTimeout(() => {
+                this._automaticEndTimeout = null;
+                this.endScene();
+            }, turnOffTimeout, this);
+        }
+    }
+    /** @inheritDoc */
+    endScene() {
+        if (this._automaticEndTimeout != null) {
+            clearTimeout(this._automaticEndTimeout);
+            this._automaticEndTimeout = null;
+        }
+        if (!this._on) {
+            return;
+        }
+        this.log(enums_1.LogLevel.Info, 'Ending scene');
+        this._on = false;
+        this._onSceneEnd();
+    }
+    /** @inheritDoc */
+    log(level, message, debugType = enums_1.LogDebugType.None) {
+        var _a, _b;
+        logging_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
+            debugType: debugType,
+            room: (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.roomName) !== null && _b !== void 0 ? _b : '',
+            deviceId: this.name,
+            deviceName: this.name,
+        });
+    }
+    /** @inheritDoc */
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    /** @inheritDoc */
+    loadDeviceSettings() {
+        this.settings.initializeFromDb(this);
+    }
+    /** @inheritDoc */
+    toJSON() {
+        // eslint-disable-next-line
+        const result = lodash_1.default.omit(this, ['room', '_onSceneStart', '_onSceneEnd']);
+        return utils_1.Utils.jsonFilter(result);
+    }
+}
+exports.RoomScene = RoomScene;

package/lib/devices/sharedFunctions/battery.d.ts

@@ -0,0 +1,30 @@
+import { iBattery, iBatteryDevice, iJsonOmitKeys } from '../../interfaces';
+import { BatteryLevelChangeAction } from '../../action';
+export declare class Battery implements iJsonOmitKeys, iBattery {
+    private readonly _device;
+    /**
+     * The last time the battery was persisted (in milliseconds since 1970)
+     */
+    private _level;
+    private _lastPersist;
+    private _lastLevel;
+    private _levelCallbacks;
+    private _lastChangeReportMs;
+    /** @inheritDoc */
+    readonly jsonOmitKeys: string[];
+    constructor(_device: iBatteryDevice);
+    get level(): number;
+    set level(val: number);
+    /** @inheritDoc */
+    persist(): void;
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    checkForChange(): void;
+    /**
+     * Adds a callback for when the battery-level has Changed.
+     * @param pCallback - Function that accepts the new state as parameter
+     */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    toJSON(): Partial<iBatteryDevice>;
+}

package/lib/devices/sharedFunctions/battery.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Battery = void 0;
+const utils_1 = require("../../utils");
+const services_1 = require("../../services");
+const action_1 = require("../../action");
+class Battery {
+    constructor(_device) {
+        this._device = _device;
+        /**
+         * The last time the battery was persisted (in milliseconds since 1970)
+         */
+        this._level = -99;
+        this._lastPersist = 0;
+        this._lastLevel = -1;
+        this._levelCallbacks = [];
+        this._lastChangeReportMs = 0;
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['_device'];
+    }
+    get level() {
+        return this._level;
+    }
+    set level(val) {
+        this._level = val;
+        this.checkForChange();
+        this.persist();
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        const now = utils_1.Utils.nowMS();
+        if (this._lastPersist + 60000 > now) {
+            return;
+        }
+        (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this._device);
+        this._lastPersist = now;
+    }
+    /**
+     * Checks whether the battery level did change and if so fires the callbacks
+     */
+    checkForChange() {
+        var _a, _b;
+        const batteryReportingInterval = (_b = (_a = this._device.settings) === null || _a === void 0 ? void 0 : _a.batteryReportingInterval) !== null && _b !== void 0 ? _b : -1;
+        if (this._level == this._lastLevel &&
+            (batteryReportingInterval < 0 || utils_1.Utils.nowMS() - this._lastChangeReportMs < batteryReportingInterval * 60 * 1000)) {
+            return;
+        }
+        this._lastChangeReportMs = utils_1.Utils.nowMS();
+        for (const cb of this._levelCallbacks) {
+            cb(new action_1.BatteryLevelChangeAction(this._device));
+        }
+        this._lastLevel = this._level;
+    }
+    /**
+     * Adds a callback for when the battery-level has Changed.
+     * @param pCallback - Function that accepts the new state as parameter
+     */
+    addBatteryLevelCallback(pCallback) {
+        this._levelCallbacks.push(pCallback);
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this, this.jsonOmitKeys);
+    }
+}
+exports.Battery = Battery;

package/lib/devices/sharedFunctions/handleSensor.d.ts

@@ -0,0 +1,44 @@
+import { iHandle, iHandleSensor, iJsonOmitKeys, iWindow } from '../../interfaces';
+import { LogDebugType, LogLevel, WindowPosition } from '../../enums';
+import { HandleChangeAction } from '../../action';
+export declare class HandleSensor implements iHandleSensor, iJsonOmitKeys {
+    private readonly _device;
+    /** @inheritDoc */
+    readonly jsonOmitKeys: string[];
+    /**
+     * The current position of the handle
+     */
+    position: WindowPosition;
+    /**
+     * The time the handle was open in minutes
+     */
+    minutesOpen: number;
+    /**
+     * The window this handle is attached to
+     */
+    window: iWindow | undefined;
+    private _lastPersist;
+    private _kippCallback;
+    private _closedCallback;
+    private _offenCallback;
+    private _handleChangeCallback;
+    private _iOpenTimeout;
+    private _helpingRoomTemp;
+    constructor(_device: iHandle);
+    private get _settings();
+    updatePosition(pValue: WindowPosition): void;
+    /** @inheritDoc */
+    addOffenCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
+    addKippCallback(pCallback: (pValue: boolean) => void): void;
+    /** @inheritDoc */
+    addClosedCallback(pCallback: (pValue: boolean) => void): void;
+    addHandleChangeCallback(cb: (handleChangeAction: HandleChangeAction) => void): void;
+    dispose(): void;
+    /**
+     * Persists the handle sensor state to the persistence layer
+     */
+    persist(): void;
+    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    toJSON(): Partial<HandleSensor>;
+}

package/lib/devices/sharedFunctions/handleSensor.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandleSensor = void 0;
+const enums_1 = require("../../enums");
+const action_1 = require("../../action");
+const utils_1 = require("../../utils");
+const weather_1 = require("../../services/weather");
+const services_1 = require("../../services");
+class HandleSensor {
+    constructor(_device) {
+        this._device = _device;
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['_device', 'window'];
+        /**
+         * The current position of the handle
+         */
+        this.position = enums_1.WindowPosition.closed;
+        /**
+         * The time the handle was open in minutes
+         */
+        this.minutesOpen = 0;
+        this._lastPersist = 0;
+        this._kippCallback = [];
+        this._closedCallback = [];
+        this._offenCallback = [];
+        this._handleChangeCallback = [];
+        this._helpingRoomTemp = false;
+    }
+    get _settings() {
+        return this._device.settings;
+    }
+    updatePosition(pValue) {
+        if (pValue === this.position) {
+            if (this._lastPersist == 0) {
+                this.persist();
+            }
+            return;
+        }
+        this.log(enums_1.LogLevel.Debug, `Update Windowhandle to position "${enums_1.WindowPosition[pValue]}"`);
+        this.position = pValue;
+        const handleChangeAction = new action_1.HandleChangeAction(this._device);
+        for (const c1 of this._closedCallback) {
+            c1(pValue === 0);
+        }
+        for (const c2 of this._kippCallback) {
+            c2(pValue === 1);
+        }
+        for (const c3 of this._offenCallback) {
+            c3(pValue === 2);
+        }
+        for (const c4 of this._handleChangeCallback) {
+            c4(handleChangeAction);
+        }
+        this.persist();
+        if (pValue === enums_1.WindowPosition.closed) {
+            if (this._iOpenTimeout !== undefined) {
+                clearInterval(this._iOpenTimeout);
+                this.log(enums_1.LogLevel.Info, `Window closed after ${this.minutesOpen} minutes`);
+                this.minutesOpen = 0;
+                this._iOpenTimeout = undefined;
+            }
+            return;
+        }
+        if (this._iOpenTimeout !== undefined) {
+            return;
+        }
+        this._iOpenTimeout = utils_1.Utils.guardedInterval(() => {
+            var _a;
+            this.minutesOpen++;
+            const heatgroup = (_a = this.window) === null || _a === void 0 ? void 0 : _a.getRoom().HeatGroup;
+            if (heatgroup !== undefined) {
+                const desiredTemp = heatgroup.desiredTemp;
+                const currentTemp = heatgroup.temperature;
+                const outSideTemp = weather_1.WeatherService.currentTemp;
+                // Check if any of these values are unavailable
+                if (desiredTemp > -99 && currentTemp > -99 && outSideTemp > -99) {
+                    const wouldHelp = (desiredTemp < currentTemp && outSideTemp < currentTemp) ||
+                        (desiredTemp > currentTemp && outSideTemp > currentTemp);
+                    if (!wouldHelp && this._helpingRoomTemp) {
+                        const info = "Window should be closed, as it doesn't help reaching target temperature.";
+                        this.log(enums_1.LogLevel.Info, info);
+                        if (this._settings.informNotHelping) {
+                            services_1.TelegramService.inform(info);
+                        }
+                        this._helpingRoomTemp = false;
+                    }
+                    else if (wouldHelp && !this._helpingRoomTemp) {
+                        this._helpingRoomTemp = true;
+                        const info = `Das Fenster hilft der Innentemperatur ihr Ziel von ${desiredTemp} zu erreichen. Draußen sind es ${outSideTemp}. Du wirst informiert wenn es nicht mehr hilft.`;
+                        this.log(enums_1.LogLevel.Info, info);
+                        if (this._settings.informIsHelping) {
+                            services_1.TelegramService.inform(info);
+                        }
+                        return;
+                    }
+                    else if (wouldHelp && this._helpingRoomTemp) {
+                        return;
+                    }
+                }
+            }
+            const message = `Window is in position ${enums_1.WindowPosition[this.position]} since ${this.minutesOpen} minutes`;
+            switch (this.minutesOpen) {
+                case 15:
+                case 30:
+                case 60:
+                case 120:
+                case 240:
+                    this.log(enums_1.LogLevel.Info, message);
+                    if (this._settings.informOnOpen) {
+                        services_1.TelegramService.inform(`${this._device.info.room}: ${message}`);
+                    }
+                    break;
+                default:
+                    this.log(enums_1.LogLevel.Trace, message);
+                    break;
+            }
+        }, 60000, this);
+    }
+    /** @inheritDoc */
+    addOffenCallback(pCallback) {
+        this._offenCallback.push(pCallback);
+    }
+    /** @inheritDoc */
+    addKippCallback(pCallback) {
+        this._kippCallback.push(pCallback);
+    }
+    /** @inheritDoc */
+    addClosedCallback(pCallback) {
+        this._closedCallback.push(pCallback);
+    }
+    addHandleChangeCallback(cb) {
+        this._handleChangeCallback.push(cb);
+    }
+    dispose() {
+        if (this._iOpenTimeout) {
+            clearInterval(this._iOpenTimeout);
+            this._iOpenTimeout = undefined;
+        }
+    }
+    /**
+     * Persists the handle sensor state to the persistence layer
+     */
+    persist() {
+        var _a;
+        const now = utils_1.Utils.nowMS();
+        if (this._lastPersist + 2000 > now) {
+            return;
+        }
+        this.log(enums_1.LogLevel.Debug, `Persist handle state: ${this.position}`);
+        (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.persistHandleSensor(this._device);
+        this._lastPersist = now;
+    }
+    log(level, message, debugType = enums_1.LogDebugType.None) {
+        this._device.log(level, message, debugType);
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this, this.jsonOmitKeys);
+    }
+}
+exports.HandleSensor = HandleSensor;

package/lib/devices/sharedFunctions/humiditySensor.d.ts

@@ -0,0 +1,17 @@
+import { iHumidityCollector, iHumiditySensor } from '../../interfaces';
+import { HumiditySensorChangeAction } from '../../action';
+export declare class HumiditySensor implements iHumiditySensor {
+    private readonly _device;
+    /** @inheritDoc */
+    readonly jsonOmitKeys: string[];
+    private _humidityCallbacks;
+    private _humidity;
+    private readonly _persistHumiditySensorInterval;
+    constructor(_device: iHumidityCollector);
+    get humidity(): number;
+    set humidity(val: number);
+    dispose(): void;
+    persist(): void;
+    addHumidityCallback(pCallback: (action: HumiditySensorChangeAction) => void): void;
+    toJSON(): Partial<HumiditySensor>;
+}

package/lib/devices/sharedFunctions/humiditySensor.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HumiditySensor = void 0;
+const interfaces_1 = require("../../interfaces");
+const action_1 = require("../../action");
+const utils_1 = require("../../utils");
+const services_1 = require("../../services");
+class HumiditySensor {
+    constructor(_device) {
+        this._device = _device;
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['_device'];
+        this._humidityCallbacks = [];
+        this._humidity = interfaces_1.UNDEFINED_TEMP_VALUE;
+        this._persistHumiditySensorInterval = utils_1.Utils.guardedInterval(() => {
+            this.persist();
+        }, 5 * 60 * 1000, this, false);
+    }
+    get humidity() {
+        return this._humidity;
+    }
+    set humidity(val) {
+        this._humidity = val;
+        for (const cb of this._humidityCallbacks) {
+            cb(new action_1.HumiditySensorChangeAction(this._device, val));
+        }
+    }
+    dispose() {
+        if (this._persistHumiditySensorInterval) {
+            clearInterval(this._persistHumiditySensorInterval);
+        }
+    }
+    persist() {
+        var _a;
+        (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.persistHumiditySensor(this._device);
+    }
+    addHumidityCallback(pCallback) {
+        this._humidityCallbacks.push(pCallback);
+        if (this._humidity > 0) {
+            pCallback(new action_1.HumiditySensorChangeAction(this._device, this._humidity));
+        }
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this, this.jsonOmitKeys);
+    }
+}
+exports.HumiditySensor = HumiditySensor;

package/lib/devices/sharedFunctions/lampUtils.d.ts

@@ -0,0 +1,19 @@
+import { ActuatorSetStateCommand, DimmerSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../command';
+import { iActuator, iDimmableLamp, iLamp } from '../../interfaces';
+export declare class LampUtils {
+    private static stromStossContinueTimeouts;
+    static stromStossOn(actuator: iActuator): void;
+    static setTimeBased(device: iLamp, c: LampSetTimeBasedCommand): void;
+    static checkUnBlock(device: iActuator, command: ActuatorSetStateCommand): boolean;
+    static toggleLight(device: iLamp, c: LampToggleLightCommand): boolean;
+    static checkBlockActive(device: iActuator, c: ActuatorSetStateCommand): boolean;
+    /**
+     * Check if the dimmer is already in the desired state thus allowing to skip this command
+     * @param {iDimmableLamp} device - The device to check
+     * @param {DimmerSetLightCommand} c - The command to check
+     * @returns {boolean} - True if the command can be skipped
+     */
+    static canDimmerChangeBeSkipped(device: iDimmableLamp, c: DimmerSetLightCommand): boolean;
+    static canActuatorChangeBeSkipped(device: iActuator, c: ActuatorSetStateCommand, noLog?: boolean): boolean;
+    static setActuator(device: iActuator, c: ActuatorSetStateCommand): void;
+}