hoffmation-base 3.0.0-alpha.23 → 3.0.0-alpha.25

package/lib/server/devices/dachs/dachsTemperatureSensor.d.ts

@@ -6,33 +6,52 @@ import { DeviceType } from '../deviceType';
 import { DeviceInfo } from '../DeviceInfo';
 import { DeviceSettings, LogLevel, RoomBase } from '../../../models';
 export declare class DachsTemperatureSensor implements iTemperatureSensor {
+    /** @inheritDoc */
     settings: DeviceSettings | undefined;
+    /** @inheritDoc */
     readonly deviceType: DeviceType;
+    /** @inheritDoc */
     readonly deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
     readonly persistTemperatureSensorInterval: NodeJS.Timeout;
     private _temperaturCallbacks;
     private _roomTemperature;
     protected _info: DeviceInfo;
     constructor(roomName: string, shortKey: string, longKey: string);
+    /** @inheritDoc */
     get customName(): string;
+    /** @inheritDoc */
     get info(): DeviceInfo;
-    set info(info: DeviceInfo);
+    /** @inheritDoc */
     get id(): string;
     get name(): string;
+    /** @inheritDoc */
     get room(): RoomBase | undefined;
+    /** @inheritDoc */
     get roomTemperature(): number;
+    /** @inheritDoc */
     set roomTemperature(value: number);
+    /** @inheritDoc */
     get iTemperature(): number;
+    /** @inheritDoc */
     get sTemperature(): string;
     private _temperature;
     private set temperature(value);
     update(newTemp: number): void;
+    /** @inheritDoc */
     addTempChangeCallback(pCallback: (pValue: number) => void): void;
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
+    /** @inheritDoc */
     persistTemperaturSensor(): void;
+    /** @inheritDoc */
     log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    /** @inheritDoc */
     toJSON(): Partial<OwnSonosDevice>;
+    /** @inheritDoc */
     persistDeviceInfo(): void;
+    /** @inheritDoc */
     loadDeviceSettings(): void;
+    /** @inheritDoc */
     dispose(): void;
 }

package/lib/server/devices/dachs/dachsTemperatureSensor.js

@@ -13,9 +13,13 @@ const devices_1 = require("../devices");
 const lodash_1 = __importDefault(require("lodash"));
 class DachsTemperatureSensor {
     constructor(roomName, shortKey, longKey) {
+        /** @inheritDoc */
         this.settings = undefined;
+        /** @inheritDoc */
         this.deviceType = deviceType_1.DeviceType.DachsWarmWaterTemperature;
+        /** @inheritDoc */
         this.deviceCapabilities = [];
+        /** @inheritDoc */
         this.persistTemperatureSensorInterval = services_1.Utils.guardedInterval(() => {
             this.persistTemperaturSensor();
         }, 5 * 60 * 1000, this, false);
@@ -33,15 +37,15 @@ class DachsTemperatureSensor {
         this.persistDeviceInfo();
         services_1.Utils.guardedTimeout(this.loadDeviceSettings, 200, this);
     }
+    /** @inheritDoc */
     get customName() {
         return this.info.customName;
     }
+    /** @inheritDoc */
     get info() {
         return this._info;
     }
-    set info(info) {
-        this._info = info;
-    }
+    /** @inheritDoc */
     get id() {
         var _a;
         return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `dachs-${this.info.room}-${this.info.customName}`;
@@ -49,18 +53,23 @@ class DachsTemperatureSensor {
     get name() {
         return this.info.customName;
     }
+    /** @inheritDoc */
     get room() {
         return services_1.API.getRoom(this.info.room);
     }
+    /** @inheritDoc */
     get roomTemperature() {
         return this._roomTemperature;
     }
+    /** @inheritDoc */
     set roomTemperature(value) {
         this._roomTemperature = value;
     }
+    /** @inheritDoc */
     get iTemperature() {
         return this._temperature;
     }
+    /** @inheritDoc */
     get sTemperature() {
         return `${this._temperature}°C`;
     }
@@ -73,19 +82,23 @@ class DachsTemperatureSensor {
     update(newTemp) {
         this.temperature = newTemp;
     }
+    /** @inheritDoc */
     addTempChangeCallback(pCallback) {
         this._temperaturCallbacks.push(pCallback);
         if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
             pCallback(this._temperature);
         }
     }
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperature = newTemperatur;
     }
+    /** @inheritDoc */
     persistTemperaturSensor() {
         var _a;
         (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistTemperatureSensor(this);
     }
+    /** @inheritDoc */
     log(level, message, debugType = services_1.LogDebugType.None) {
         services_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
             debugType: debugType,
@@ -94,19 +107,23 @@ class DachsTemperatureSensor {
             deviceName: this.name,
         });
     }
+    /** @inheritDoc */
     toJSON() {
         return services_1.Utils.jsonFilter(lodash_1.default.omit(this, ['room', 'client', 'config', '_influxClient']));
     }
+    /** @inheritDoc */
     persistDeviceInfo() {
         services_1.Utils.guardedTimeout(() => {
             var _a;
             (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
         }, 5000, this);
     }
+    /** @inheritDoc */
     loadDeviceSettings() {
         var _a;
         (_a = this.settings) === null || _a === void 0 ? void 0 : _a.initializeFromDb(this);
     }
+    /** @inheritDoc */
     dispose() {
         if (this.persistTemperatureSensorInterval) {
             clearInterval(this.persistTemperatureSensorInterval);

package/lib/server/devices/dachs/interfaces/DachsClientOptions.d.ts

@@ -1,12 +1,42 @@
+/**
+ * Options to connect to a Dachs CHP device
+ */
 export interface DachsClientOptions {
+    /**
+     * The hostname or IP address of the Dachs device
+     */
     host: string;
+    /**
+     * The protocol to use
+     */
     protocol?: 'http' | 'https';
+    /**
+     * The port to use
+     */
     port?: number;
+    /**
+     * The username to use for authentication
+     */
     username?: string;
+    /**
+     * The password to use for authentication
+     */
     password?: string;
+    /**
+     * Settings to define the result of requests
+     */
     resultConfig?: {
+        /**
+         * Whether to add the raw value to the result
+         */
         addRawValue?: boolean;
+        /**
+         * Whether to add the key object to the result
+         */
         addKeyObject?: boolean;
+        /**
+         * Whether to flatten the result
+         */
         flatten?: boolean;
     };
 }

package/lib/server/devices/dachs/interfaces/dachsInfluxDataPoint.d.ts

@@ -1,6 +1,18 @@
+/**
+ * Represents a data point that can be written to the persistence layer
+ */
 export interface DachsInfluxDataPoint {
+    /**
+     * The timestamp of the data point
+     */
     timestamp: Date;
+    /**
+     * The measurement of the data point
+     */
     measurement: string;
+    /**
+     * The fields of the data point
+     */
     fields: {
         [key: string]: string | number | boolean;
     };

package/lib/server/devices/dachs/interfaces/influxDbConnectionOptions.d.ts

@@ -1,9 +1,29 @@
+/**
+ * The options needed for connecting to an InfluxDB database
+ */
 export interface InfluxDbConnectionOptions {
+    /**
+     * The host address of the InfluxDB server (or its ip address)
+     */
     host: string;
+    /**
+     * The port of the InfluxDB server
+     */
     port: number;
+    /**
+     * The name of the database to connect to
+     */
     database: string;
+    /**
+     * The username to use for authentication
+     */
     username: string;
+    /**
+     * The password to use for authentication
+     */
     password: string;
+    /**
+     * The retention policy to use for writing data (if not specified, the default retention policy is used)
+     */
     retentionPolicy?: string;
-    batchIntervalSeconds?: number;
 }

package/lib/server/devices/dachs/lib/dachsHttpClient.js

@@ -89,7 +89,7 @@ class DachsHttpClient {
     fetchByKeys(...keys) {
         return new Promise((resolve, reject) => {
             this.axiosInstance
-                .get(`/getKey` + this.urlBuilder(keys))
+                .get("/getKey" + this.urlBuilder(keys))
                 .then((res) => {
                 if (!res.data)
                     reject('No data received');
@@ -117,7 +117,7 @@ class DachsHttpClient {
     setKeys(data) {
         return new Promise((resolve, reject) => {
             this.axiosInstance
-                .post(`/setKeys`, Object.entries(data)
+                .post("/setKeys", Object.entries(data)
                 .map(([key, value]) => `${key}=${value}`)
                 .join('&'))
                 .then((res) => {

package/lib/server/devices/device-cluster.d.ts

@@ -10,6 +10,9 @@ export declare class DeviceCluster {
     addByDeviceType(device: iBaseDevice): void;
     addToList(type: DeviceClusterType, device: iBaseDevice): void;
     toJSON(): Partial<DeviceCluster & {
+        /**
+         * Dictionary representation of the normal device map
+         */
         deviceDict?: {
             [p: string]: DeviceList;
         };

package/lib/server/devices/device-cluster.js

@@ -11,7 +11,7 @@ class DeviceCluster {
     }
     getIoBrokerDevicesByType(type) {
         if (type === device_cluster_type_1.DeviceClusterType.Speaker) {
-            throw new Error(`This is no IoBroker Device`);
+            throw new Error('This is no IoBroker Device');
         }
         return this.getDevicesByType(type);
     }

package/lib/server/devices/deviceUpdater.d.ts

@@ -1,8 +1,5 @@
 import { IDeviceUpdater } from './iDeviceUpdater';
-import { Devices } from './devices';
 export declare class DeviceUpdater implements IDeviceUpdater {
-    devices: Devices;
-    constructor(pDevices: Devices);
     updateObject(pId: string, pObj: ioBroker.Object): void;
     updateState(id: string, state: ioBroker.State, initial?: boolean): void;
 }

package/lib/server/devices/deviceUpdater.js

@@ -7,9 +7,6 @@ const devices_1 = require("./devices");
 const mqtt_1 = require("./mqtt");
 const IoBrokerDeviceInfo_1 = require("./IoBrokerDeviceInfo");
 class DeviceUpdater {
-    constructor(pDevices) {
-        this.devices = pDevices;
-    }
     updateObject(pId, pObj) {
         const idSplit = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.idSplitter(pId);
         if (idSplit.length < 2)
@@ -40,7 +37,7 @@ class DeviceUpdater {
             classifier = devices_1.Devices.IDENTIFIER_ZIGBEE;
             devId = idSplit[2].substring(2);
         }
-        const device = devices_1.Devices.alLDevices[`${classifier}-${devId}`];
+        const device = services_1.API.getDevice(`${classifier}-${devId}`);
         if (typeof device === 'undefined' || device.update === undefined) {
             return;
         }

package/lib/server/devices/devices.d.ts

@@ -3,18 +3,54 @@ import { iBaseDevice, iEnergyManager, iTemperatureSensor } from './baseDeviceInt
 import { Dachs } from './dachs';
 import { iConfig } from '../config';
 export declare class Devices {
-    static IDENTIFIER_HOMEMATIC: string;
-    static IDENTIFIER_JS: string;
-    static IDENTIFIER_Shelly: string;
-    static IDENTIFIER_TUYA: string;
-    static IDENTIFIER_ZIGBEE: string;
-    static IDENTIFIER_ZIGBEE2MQTT: string;
-    static IDENTIFIER_WLED: string;
+    /**
+     * A constant for the identifier of HM-IP Adapter devices
+     */
+    static readonly IDENTIFIER_HOMEMATIC: string;
+    /**
+     * A constant for the identifier of JavaScript Adapter devices
+     */
+    static readonly IDENTIFIER_JS: string;
+    /**
+     * A constant for the identifier of Shelly Adapter devices
+     */
+    static readonly IDENTIFIER_Shelly: string;
+    /**
+     * A constant for the identifier of Tuya Adapter devices
+     */
+    static readonly IDENTIFIER_TUYA: string;
+    /**
+     * A constant for the identifier of Zigbee Adapter devices
+     */
+    static readonly IDENTIFIER_ZIGBEE: string;
+    /**
+     * A constant for the identifier of Zigbee2Mqtt Adapter devices
+     */
+    static readonly IDENTIFIER_ZIGBEE2MQTT: string;
+    /**
+     * A constant for the identifier of WLED Adapter devices
+     */
+    static readonly IDENTIFIER_WLED: string;
+    /**
+     * A Map containing all devices
+     */
     static alLDevices: {
         [id: string]: iBaseDevice;
     };
+    /**
+     * A reference to globally active energy manager
+     * @default undefined (no Energy-Manager)
+     */
     static energymanager?: iEnergyManager;
+    /**
+     * A reference to the Dachs device
+     * @default undefined (no Dachs CHP)
+     */
     static dachs?: Dachs;
+    /**
+     * A reference to the temperature sensor measuring the warm water temperature
+     * @default undefined (no warm water temperature sensor)
+     */
     static temperatureWarmWater?: iTemperatureSensor;
     constructor(pDeviceData: {
         [id: string]: deviceConfig;

package/lib/server/devices/devices.js

@@ -17,7 +17,7 @@ class Devices {
         var _a;
         // This forces import of rooms at correct timing, to allow devices to land in proper rooms.
         pRoomImportEnforcer === null || pRoomImportEnforcer === void 0 ? void 0 : pRoomImportEnforcer.addRoomConstructor();
-        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Constructing devices now`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Constructing devices now');
         for (const cID in pDeviceData) {
             const cDevConf = pDeviceData[cID];
             if (!cDevConf.common ||
@@ -46,7 +46,7 @@ class Devices {
             else if (cName.indexOf('00-EnergyManager') === 0 &&
                 cDevConf.type !== 'folder' &&
                 !((_a = config === null || config === void 0 ? void 0 : config.energyManager) === null || _a === void 0 ? void 0 : _a.disableJsEnergyManager)) {
-                services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Found Energy-Manager in Device json.`);
+                services_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Found Energy-Manager in Device json.');
                 Devices.createEnergyManager(cDevConf);
             }
         }
@@ -59,20 +59,20 @@ class Devices {
         // Nothing yet
     }
     static resetDetectionsToday() {
-        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `3 o'clock reset of motion sensors`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, "3 o'clock reset of motion sensors");
         for (const dID in Devices.alLDevices) {
             const d = Devices.alLDevices[dID];
             if (d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.motionSensor)) {
-                d.log(models_1.LogLevel.Debug, `3 o'clock reset of detections`);
+                d.log(models_1.LogLevel.Debug, "3 o'clock reset of detections");
                 d.detectionsToday = 0;
             }
         }
     }
     static getBatteryInfo() {
-        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Getting Battery Info`);
+        services_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Getting Battery Info');
         let data = [];
         const result = [
-            `These are the battery values for each device. Device dependandt some are in volts, some in %`,
+            'These are the battery values for each device. Device dependandt some are in volts, some in %',
         ];
         for (const key in this.alLDevices) {
             const d = this.alLDevices[key];
@@ -296,14 +296,50 @@ class Devices {
     }
 }
 exports.Devices = Devices;
+/**
+ * A constant for the identifier of HM-IP Adapter devices
+ */
 Devices.IDENTIFIER_HOMEMATIC = 'hm-rpc';
+/**
+ * A constant for the identifier of JavaScript Adapter devices
+ */
 Devices.IDENTIFIER_JS = 'javascript';
+/**
+ * A constant for the identifier of Shelly Adapter devices
+ */
 Devices.IDENTIFIER_Shelly = 'shelly';
+/**
+ * A constant for the identifier of Tuya Adapter devices
+ */
 Devices.IDENTIFIER_TUYA = 'tuya';
+/**
+ * A constant for the identifier of Zigbee Adapter devices
+ */
 Devices.IDENTIFIER_ZIGBEE = 'zigbee';
+/**
+ * A constant for the identifier of Zigbee2Mqtt Adapter devices
+ */
 Devices.IDENTIFIER_ZIGBEE2MQTT = 'zigbee2mqtt';
+/**
+ * A constant for the identifier of WLED Adapter devices
+ */
 Devices.IDENTIFIER_WLED = 'wled';
+/**
+ * A Map containing all devices
+ */
 Devices.alLDevices = {};
+/**
+ * A reference to globally active energy manager
+ * @default undefined (no Energy-Manager)
+ */
 Devices.energymanager = undefined;
+/**
+ * A reference to the Dachs device
+ * @default undefined (no Dachs CHP)
+ */
 Devices.dachs = undefined;
+/**
+ * A reference to the temperature sensor measuring the warm water temperature
+ * @default undefined (no warm water temperature sensor)
+ */
 Devices.temperatureWarmWater = undefined;

package/lib/server/devices/espresense/detectedBluetoothDevice.d.ts

@@ -9,12 +9,25 @@ import { TrackedDistanceData } from './trackedDistanceData';
 import { iBluetoothDetector } from '../baseDeviceInterfaces/iBluetoothDetector';
 export declare class DetectedBluetoothDevice implements iBaseDevice {
     id: string;
+    /** @inheritDoc */
     settings: undefined;
+    /**
+     * A Map matching the distances to the trackers identified by {@link iBluetoothDetector.id}
+     */
     distanceMap: Map<string, TrackedDistanceData>;
+    /** @inheritDoc */
     readonly deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
     deviceType: DeviceType;
+    /** @inheritDoc */
     info: DeviceInfo;
+    /**
+     * The last room the device was guessed to be in {@link iRoomBase.roomName}
+     */
     lastRoom: string | undefined;
+    /**
+     * If the device is currently present
+     */
     present: boolean;
     constructor(id: string, settings?: iBluetoothTrackingSettings);
     get customName(): string;

package/lib/server/devices/espresense/detectedBluetoothDevice.js

@@ -13,12 +13,25 @@ const trilaterationPointDistance_1 = require("./trilaterationPointDistance");
 class DetectedBluetoothDevice {
     constructor(id, settings) {
         this.id = id;
+        /** @inheritDoc */
         this.settings = undefined;
+        /**
+         * A Map matching the distances to the trackers identified by {@link iBluetoothDetector.id}
+         */
         this.distanceMap = new Map();
+        /** @inheritDoc */
         this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.trackableDevice];
+        /** @inheritDoc */
         this.deviceType = deviceType_1.DeviceType.TrackableDevice;
+        /** @inheritDoc */
         this.info = new DeviceInfo_1.DeviceInfo();
+        /**
+         * The last room the device was guessed to be in {@link iRoomBase.roomName}
+         */
         this.lastRoom = undefined;
+        /**
+         * If the device is currently present
+         */
         this.present = false;
         if (settings === undefined) {
             return;

package/lib/server/devices/espresense/espresenseDevice.d.ts

@@ -8,27 +8,57 @@ import { LogDebugType } from '../../services';
 import { ProximityCallback } from './proximityCallback';
 import { TrilaterationBasePoint } from './trilaterationBasePoint';
 export declare class EspresenseDevice implements iRoomDevice, iBluetoothDetector {
+    /** @inheritDoc */
     readonly position: TrilaterationBasePoint;
+    /** @inheritDoc */
     settings: undefined;
+    /** @inheritDoc */
     readonly deviceCapabilities: DeviceCapability[];
+    /** @inheritDoc */
     deviceType: DeviceType;
+    /**
+     * The name of this device
+     */
     readonly name: string;
     private deviceMap;
     private proximityCallbackMap;
+    /**
+     * Creates a new instance of the EspresenseDevice class
+     * @param name - The desired name of the device
+     * @param roomName - The name of the room this device is in {@link iRoomBase.roomName}
+     * @param x - The x coordinate of the device in the house
+     * @param y - The y coordinate of the device in the house
+     * @param z - The z coordinate of the device in the house
+     */
     constructor(name: string, roomName: string, x: number, y: number, z: number);
+    /** @inheritDoc */
     get customName(): string;
     protected _info: DeviceInfo;
+    /** @inheritDoc */
     get info(): DeviceInfo;
-    set info(info: DeviceInfo);
+    /** @inheritDoc */
     get id(): string;
+    /** @inheritDoc */
     get room(): RoomBase | undefined;
+    /** @inheritDoc */
     distanceOfDevice(deviceName: string, maxAge?: number): number | undefined;
+    /** @inheritDoc */
     isDevicePresent(deviceName: string, maxDistance: number, maxAge?: number): boolean;
+    /**
+     * Updates the device with the given state
+     * @param devName - The name of the bluetooth device
+     * @param state - The state containing the json-formatted distance data
+     */
     update(devName: string, state: ioBroker.State): void;
+    /** @inheritDoc */
     log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    /** @inheritDoc */
     toJSON(): Partial<iRoomDevice>;
+    /** @inheritDoc */
     persistDeviceInfo(): void;
+    /** @inheritDoc */
     loadDeviceSettings(): void;
+    /** @inheritDoc */
     addProximityCallback(cb: ProximityCallback): void;
     private addDeviceTracking;
 }