hoffmation-base 3.0.0-alpha.9 → 3.0.0-alpha.90

package/lib/server/devices/zigbee/zigbeeSonoffTemp.js

@@ -2,121 +2,85 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeSonoffTemp = void 0;
 const BaseDevices_1 = require("./BaseDevices");
-const baseDeviceInterfaces_1 = require("../baseDeviceInterfaces");
 const deviceType_1 = require("../deviceType");
 const DeviceCapability_1 = require("../DeviceCapability");
 const models_1 = require("../../../models");
-const services_1 = require("../../services");
+const sharedFunctions_1 = require("../sharedFunctions");
 class ZigbeeSonoffTemp extends BaseDevices_1.ZigbeeDevice {
-    get lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
-    get battery() {
-        return this._battery;
-    }
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeSonoffTemp);
-        this._battery = -99;
-        this._lastBatteryPersist = 0;
-        this.persistTemperatureSensorInterval = services_1.Utils.guardedInterval(() => {
-            this.persistTemperaturSensor();
-        }, 5 * 60 * 1000, this, false);
-        this.persistHumiditySensorInterval = services_1.Utils.guardedInterval(() => {
-            this.persistHumiditySensor();
-        }, 5 * 60 * 1000, this, false);
-        this._humidityCallbacks = [];
-        this._temperaturCallbacks = [];
-        this._humidity = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
-        this._roomTemperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
-        this._temperature = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
+        /** @inheritDoc */
+        this.temperatureSensor = new sharedFunctions_1.TemperatureSensor(this);
+        /** @inheritDoc */
+        this.humiditySensor = new sharedFunctions_1.HumiditySensor(this);
+        /** @inheritDoc */
+        this.battery = new sharedFunctions_1.Battery(this);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.temperatureSensor);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.humiditySensor);
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
     }
+    /** @inheritDoc */
+    get batteryLevel() {
+        return this.battery.level;
+    }
+    /** @inheritDoc */
     get roomTemperature() {
-        return this._roomTemperature;
+        return this.temperatureSensor.roomTemperature;
     }
+    /** @inheritDoc */
     set roomTemperature(value) {
-        this._roomTemperature = value;
+        this.temperatureSensor.roomTemperature = value;
     }
+    /** @inheritDoc */
     get humidity() {
-        return this._humidity;
-    }
-    set humidity(val) {
-        this._humidity = val;
-        for (const cb of this._humidityCallbacks) {
-            cb(val);
-        }
+        return this.humiditySensor.humidity;
     }
+    /** @inheritDoc */
     get iTemperature() {
-        return this._temperature;
+        return this.temperatureSensor.temperature;
     }
+    /** @inheritDoc */
     get sTemperature() {
-        return `${this._temperature}°C`;
+        return `${this.temperatureSensor.temperature}°C`;
     }
-    set temperature(val) {
-        this._temperature = val;
-        for (const cb of this._temperaturCallbacks) {
-            cb(val);
-        }
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this.battery.addBatteryLevelCallback(pCallback);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         super.update(idSplit, state, initial, true);
         switch (idSplit[3]) {
             case 'battery':
-                this._battery = state.val;
-                this.persistBatteryDevice();
-                if (this._battery < 20) {
-                    this.log(models_1.LogLevel.Warn, `Das Zigbee Gerät hat unter 20% Batterie.`);
+                this.battery.level = state.val;
+                if (this.batteryLevel < 20) {
+                    this.log(models_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
                 }
                 break;
             case 'humidity':
-                this.humidity = state.val;
+                this.humiditySensor.humidity = state.val;
                 break;
             case 'temperature':
-                this.temperature = state.val;
+                this.temperatureSensor.temperature = state.val;
                 break;
         }
     }
+    /** @inheritDoc */
     addHumidityCallback(pCallback) {
-        this._humidityCallbacks.push(pCallback);
-        if (this._humidity > 0) {
-            pCallback(this._humidity);
-        }
+        this.humiditySensor.addHumidityCallback(pCallback);
     }
+    /** @inheritDoc */
     addTempChangeCallback(pCallback) {
-        this._temperaturCallbacks.push(pCallback);
-        if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
-            pCallback(this._temperature);
-        }
+        this.temperatureSensor.addTempChangeCallback(pCallback);
     }
+    /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperature = newTemperatur;
     }
-    persistTemperaturSensor() {
-        var _a;
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistTemperatureSensor(this);
-    }
-    persistHumiditySensor() {
-        var _a;
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHumiditySensor(this);
-    }
-    persistBatteryDevice() {
-        var _a;
-        const now = services_1.Utils.nowMS();
-        if (this._lastBatteryPersist + 60000 > now) {
-            return;
-        }
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
-        this._lastBatteryPersist = now;
-    }
+    /** @inheritDoc */
     dispose() {
-        if (this.persistTemperatureSensorInterval) {
-            clearInterval(this.persistTemperatureSensorInterval);
-        }
-        if (this.persistHumiditySensorInterval) {
-            clearInterval(this.persistHumiditySensorInterval);
-        }
+        this.temperatureSensor.dispose();
+        this.humiditySensor.dispose();
         super.dispose();
     }
 }

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

@@ -1,18 +1,25 @@
 import { ZigbeeHeater } from './BaseDevices';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeTuyaValve extends ZigbeeHeater {
-    private _setLocalTempCalibrationId;
+    private readonly _setLocalTempCalibrationId;
     private _targetTempVal;
     private _localTempVal;
     private _localDiffTempVal;
     private _setModeId;
     private _mode;
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeTuyaValve}.
+     * @param pInfo - Device creation information
+     */
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     set seasonTurnOff(value: boolean);
-    get roomTemperatur(): number;
-    set roomTemperatur(value: number);
+    /** @inheritDoc */
     set desiredTemperature(val: number);
+    /** @inheritDoc */
+    protected set roomTemperatur(value: number);
     private get tempDiff();
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     private checkTempDiff;
     private setLocalDiff;

package/lib/server/devices/zigbee/zigbeeTuyaValve.js

@@ -7,6 +7,10 @@ const baseDeviceInterfaces_1 = require("../baseDeviceInterfaces");
 const models_1 = require("../../../models");
 const services_1 = require("../../services");
 class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeTuyaValve}.
+     * @param pInfo - Device creation information
+     */
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeTuyaValve);
         this._targetTempVal = baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE;
@@ -17,13 +21,17 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         this._setLocalTempCalibrationId = `${this.info.fullID}.local_temp_calibration`;
         this._setModeId = `${this.info.fullID}.mode`;
     }
+    /** @inheritDoc */
     set seasonTurnOff(value) {
         this._seasonTurnOff = value;
         this.setMode(value ? 'off' : 'auto');
     }
-    get roomTemperatur() {
-        return this._roomTemperature;
+    /** @inheritDoc */
+    set desiredTemperature(val) {
+        this._desiredTemperatur = val;
+        this.checkTempDiff();
     }
+    /** @inheritDoc */
     set roomTemperatur(value) {
         this._roomTemperature = value;
         if (this.settings.useOwnTemperatur) {
@@ -31,13 +39,10 @@ class ZigbeeTuyaValve extends BaseDevices_1.ZigbeeHeater {
         }
         this.checkTempDiff();
     }
-    set desiredTemperature(val) {
-        this._desiredTemperatur = val;
-        this.checkTempDiff();
-    }
     get tempDiff() {
         return this._targetTempVal - (this._localTempVal + this._localDiffTempVal);
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'valve_position':

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

@@ -4,8 +4,15 @@ import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { iLoadMeter } from '../baseDeviceInterfaces/iLoadMeter';
 export declare class ZigbeeUbisysActuator extends ZigbeeActuator implements iLoadMeter {
     private _loadPower;
+    protected readonly _actuatorOnStateIdState: string;
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeUbisysActuator} or a derived class like {@link ZigbeeUbisysLampe}
+     * @param pInfo - Device creation information
+     * @param deviceType - The device type (if not {@link DeviceType.ZigbeeUbisysActuator})
+     */
     constructor(pInfo: IoBrokerDeviceInfo, deviceType?: DeviceType);
-    get isActuatorOn(): boolean;
+    /** @inheritDoc */
     get loadPower(): number;
-    update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
 }

package/lib/server/devices/zigbee/zigbeeUbisysActuator.js

@@ -6,21 +6,23 @@ const models_1 = require("../../../models");
 const deviceType_1 = require("../deviceType");
 const DeviceCapability_1 = require("../DeviceCapability");
 class ZigbeeUbisysActuator extends BaseDevices_1.ZigbeeActuator {
+    /**
+     * Creates an instance of {@link DeviceType.ZigbeeUbisysActuator} or a derived class like {@link ZigbeeUbisysLampe}
+     * @param pInfo - Device creation information
+     * @param deviceType - The device type (if not {@link DeviceType.ZigbeeUbisysActuator})
+     */
     constructor(pInfo, deviceType = deviceType_1.DeviceType.ZigbeeUbisysActuator) {
-        super(pInfo, deviceType, `${pInfo.fullID}.state`);
+        super(pInfo, deviceType);
         this._loadPower = 0;
         this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.loadMetering);
+        this._actuatorOnStateIdState = `${pInfo.fullID}.state`;
     }
-    get isActuatorOn() {
-        return this.actuatorOn;
-    }
+    /** @inheritDoc */
     get loadPower() {
         return this._loadPower;
     }
-    update(idSplit, state, initial = false, handledByChildObject = false) {
-        if (!handledByChildObject) {
-            this.log(models_1.LogLevel.DeepTrace, `Aktuator Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
-        }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'load_power':
                 const newLoadPower = state.val;

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

@@ -1,14 +1,13 @@
-import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
 import { iLamp } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
-import { ZigbeeUbisysActuator } from './zigbeeUbisysActuator';
-export declare class ZigbeeUbisysLampe extends ZigbeeUbisysActuator implements iLamp {
+import { ZigbeeLamp } from './BaseDevices';
+import { iLoadMeter } from '../baseDeviceInterfaces/iLoadMeter';
+export declare class ZigbeeUbisysLampe extends ZigbeeLamp implements iLamp, iLoadMeter {
+    protected readonly _actuatorOnStateIdState: string;
+    private _loadPower;
     constructor(pInfo: IoBrokerDeviceInfo);
-    get lightOn(): boolean;
+    /** @inheritDoc */
+    get loadPower(): number;
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
-    /** @inheritdoc */
-    setLight(c: LampSetLightCommand): void;
-    toggleLight(c: LampToggleLightCommand): boolean;
-    setTimeBased(c: LampSetTimeBasedCommand): void;
-    persist(): void;
 }

package/lib/server/devices/zigbee/zigbeeUbisysLampe.js

@@ -3,39 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeUbisysLampe = void 0;
 const deviceType_1 = require("../deviceType");
 const models_1 = require("../../../models");
-const services_1 = require("../../services");
+const BaseDevices_1 = require("./BaseDevices");
 const DeviceCapability_1 = require("../DeviceCapability");
-const zigbeeUbisysActuator_1 = require("./zigbeeUbisysActuator");
-const sharedFunctions_1 = require("../sharedFunctions");
-class ZigbeeUbisysLampe extends zigbeeUbisysActuator_1.ZigbeeUbisysActuator {
+class ZigbeeUbisysLampe extends BaseDevices_1.ZigbeeLamp {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeUbisysLampe);
-        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.lamp);
+        this._loadPower = 0;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.loadMetering);
+        this._actuatorOnStateIdState = `${pInfo.fullID}.state`;
     }
-    get lightOn() {
-        return super.isActuatorOn;
+    /** @inheritDoc */
+    get loadPower() {
+        return this._loadPower;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
-        super.update(idSplit, state, initial, true);
         switch (idSplit[3]) {
-            case 'state':
-                this.log(models_1.LogLevel.Trace, `Lampen Update für ${this.info.customName} auf ${state.val}`);
+            case 'load_power':
+                const newLoadPower = state.val;
+                this.log(Math.abs(newLoadPower - this._loadPower) > 0.25 ? models_1.LogLevel.Trace : models_1.LogLevel.DeepTrace, `Outlet update, new current load power: ${state.val}`);
+                this._loadPower = newLoadPower;
                 break;
         }
-    }
-    /** @inheritdoc */
-    setLight(c) {
-        super.setActuator(c);
-    }
-    toggleLight(c) {
-        return sharedFunctions_1.LampUtils.toggleLight(this, c);
-    }
-    setTimeBased(c) {
-        sharedFunctions_1.LampUtils.setTimeBased(this, c);
-    }
-    persist() {
-        var _a;
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+        super.update(idSplit, state, initial, true);
     }
 }
 exports.ZigbeeUbisysLampe = ZigbeeUbisysLampe;

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

@@ -3,6 +3,7 @@ import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeUbisysShutter extends ZigbeeShutter {
     private readonly _positionStateId;
     constructor(pInfo: IoBrokerDeviceInfo);
+    /** @inheritDoc */
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     protected moveToPosition(pPosition: number): void;
 }

package/lib/server/devices/zigbee/zigbeeUbisysShutter.js

@@ -10,11 +10,12 @@ class ZigbeeUbisysShutter extends BaseDevices_1.ZigbeeShutter {
         this._positionStateId = `${this.info.fullID}.position`;
         // this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
     }
+    /** @inheritDoc */
     update(idSplit, state, initial = false) {
         switch (idSplit[3]) {
             case 'position':
                 this.log(models_1.LogLevel.Trace, `Shutter Update for ${this.info.customName} to "${state.val}"`);
-                this.currentLevel = state.val;
+                this.setCurrentLevel(state.val, initial);
                 break;
         }
         super.update(idSplit, state, initial, true);

package/lib/server/ioBroker/connection.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { IncomingMessage } from 'http';
 import { iDisposable } from '../services';
 import { ConnectionCallbacks } from '../../models';
@@ -32,79 +30,79 @@ export declare class IOBrokerConnection implements iDisposable {
     private _isExecutedInBrowser;
     /**
      * Getter isExecutedInBrowser
-     * @return {boolean }
+     * @returns
      */
     get isExecutedInBrowser(): boolean;
     private _enums?;
     /**
      * Getter enums
-     * @return {unknown}
+     * @returns
      */
     get enums(): Record<string, ioBroker.EnumObject> | undefined;
     /**
      * Setter enums
-     * @param {unknown} value
+     * @param value
      */
     set enums(value: Record<string, ioBroker.EnumObject> | undefined);
     private _isAuthDone;
     /**
      * Getter isAuthDone
-     * @return {boolean }
+     * @returns
      */
     get isAuthDone(): boolean;
     private _namespace;
     /**
      * Getter namespace
-     * @return {string }
+     * @returns
      */
     get namespace(): string;
     /**
      * Setter namespace
-     * @param {string } value
+     * @param value
      */
     set namespace(value: string);
     private _objects?;
     /**
      * Getter objects
-     * @return {unknown}
+     * @returns
      */
     get objects(): Record<string, ioBroker.Object> | undefined;
     /**
      * Setter objects
-     * @param {unknown} value
+     * @param value
      */
     set objects(value: Record<string, ioBroker.Object> | undefined);
     private _type;
     /**
      * Getter type
-     * @return {string }
+     * @returns
      */
     get type(): string;
     /**
      * Setter type
-     * @param {string } value
+     * @param value
      */
     set type(value: string);
     private _timeout;
     /**
      * Getter timeout
-     * @return {number }
+     * @returns
      */
     get timeout(): number;
     /**
      * Setter timeout
-     * @param {number } value
+     * @param value
      */
     set timeout(value: number);
     private _user;
     /**
      * Getter user
-     * @return {unknown}
+     * @returns
      */
     get user(): string;
     /**
      * Setter user
-     * @param {unknown} value
+     * @param value
      */
     set user(value: string);
     reconnect(pConnOptions: unknown): void;
@@ -113,7 +111,7 @@ export declare class IOBrokerConnection implements iDisposable {
     readFile(filename: string, callback: ioBroker.ReadFileCallback, isRemote: boolean): void;
     getMimeType(ext: string): string;
     readFile64(filename: string, callback: unknown, isRemote: boolean): void;
-    writeFile(filename: string, data: unknown | string, mode: number, callback: ioBroker.ErrnoCallback, ...args: unknown[]): void;
+    writeFile(filename: string, data: unknown | string, mode: number, callback: ioBroker.ErrnoCallback, ..._args: unknown[]): void;
     writeFile64(filename: string, data: string, callback: ioBroker.ErrnoCallback): void;
     readDir(dirname: string, callback: ioBroker.ReadDirCallback): void;
     mkdir(dirname: string, callback: ioBroker.ErrnoCallback): void;
@@ -123,16 +121,16 @@ export declare class IOBrokerConnection implements iDisposable {
     sendTo(instance: string, command: string, payload: ioBroker.MessagePayload, callback: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
     getStates(idPattern: string | undefined, callback: ioBroker.GetStatesCallback): void;
     getObjects(useCache: boolean, callback: ioBroker.GetObjectsCallback): void;
-    getChildren(id: string, useCache: boolean, callback: (err?: Error | null, children?: string[]) => void, ...args: unknown[]): void;
+    getChildren(id: string, useCache: boolean, callback: (err?: Error | null, children?: string[]) => void, ..._args: unknown[]): void;
     getObject(id: string, useCache: boolean, callback: ioBroker.GetObjectCallback): void;
     getSyncTime(): Date;
-    addObject(objId: unknown, obj: unknown, callback: unknown): void;
+    addObject(_objId: unknown, _obj: unknown, _callback: unknown): void;
     delObject(objId: string): void;
     httpGet(url: string, callback: (res: IncomingMessage | Error) => void): void;
     logError(errorText: string): void;
     authenticate(user: string, password: string, salt: string): void;
-    getConfig(useCache: boolean, callback: (error: Error | null, conf?: Record<string, any>) => void, ...args: unknown[]): void;
-    sendCommand(instance: string, command: string, data: string | number | boolean | unknown[] | Record<string, any> | null, ack?: boolean): void;
+    getConfig(useCache: boolean, callback: (error: Error | null, conf?: Record<string, unknown>) => void, ..._args: unknown[]): void;
+    sendCommand(instance: string, command: string, data: string | number | boolean | unknown[] | Record<string, unknown> | null, ack?: boolean): void;
     readProjects(callback: (err?: NodeJS.ErrnoException | null, objects?: Array<{
         name: string;
         readOnly: undefined | boolean;
@@ -142,7 +140,7 @@ export declare class IOBrokerConnection implements iDisposable {
     clearCache(): void;
     getHistory(id: string, options: ioBroker.GetHistoryOptions & {
         timeout?: number;
-    }, callback: ioBroker.GetHistoryCallback, ...args: unknown[]): void;
+    }, callback: ioBroker.GetHistoryCallback, ..._args: unknown[]): void;
     private _checkConnection;
     private _monitor;
     private _onAuth;
@@ -150,5 +148,6 @@ export declare class IOBrokerConnection implements iDisposable {
     private _fillChildren;
     private _queueCmdIfRequired;
     private _detectViews;
+    /** @inheritDoc */
     dispose(): void;
 }