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

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

@@ -2,159 +2,86 @@
 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 {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeSonoffTemp);
         /** @inheritDoc */
-        this.persistTemperatureSensorInterval = services_1.Utils.guardedInterval(() => {
-            this.persistTemperaturSensor();
-        }, 5 * 60 * 1000, this, false);
+        this.temperatureSensor = new sharedFunctions_1.TemperatureSensor(this);
         /** @inheritDoc */
-        this.persistHumiditySensorInterval = services_1.Utils.guardedInterval(() => {
-            this.persistHumiditySensor();
-        }, 5 * 60 * 1000, this, false);
-        this._battery = -99;
-        this._lastBatteryPersist = 0;
-        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;
-        this._lastBatteryLevel = -1;
-        this._batteryLevelCallbacks = [];
+        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 lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
-    /** @inheritDoc */
-    get battery() {
-        return this._battery;
+    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(new models_1.HumiditySensorChangeAction(this, val));
-        }
+        return this.humiditySensor.humidity;
     }
     /** @inheritDoc */
     get iTemperature() {
-        return this._temperature;
+        return this.temperatureSensor.temperature;
     }
     /** @inheritDoc */
     get sTemperature() {
-        return `${this._temperature}°C`;
-    }
-    set temperature(val) {
-        this._temperature = val;
-        for (const cb of this._temperaturCallbacks) {
-            cb(new models_1.TemperatureSensorChangeAction(this, val));
-        }
+        return `${this.temperatureSensor.temperature}°C`;
     }
     /** @inheritDoc */
     addBatteryLevelCallback(pCallback) {
-        this._batteryLevelCallbacks.push(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.checkForBatteryChange();
-                this.persistBatteryDevice();
-                if (this._battery < 20) {
+                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(new models_1.HumiditySensorChangeAction(this, this._humidity));
-        }
+        this.humiditySensor.addHumidityCallback(pCallback);
     }
     /** @inheritDoc */
     addTempChangeCallback(pCallback) {
-        this._temperaturCallbacks.push(pCallback);
-        if (this._temperature > baseDeviceInterfaces_1.UNDEFINED_TEMP_VALUE) {
-            pCallback(new models_1.TemperatureSensorChangeAction(this, this._temperature));
-        }
+        this.temperatureSensor.addTempChangeCallback(pCallback);
     }
     /** @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 */
-    persistHumiditySensor() {
-        var _a;
-        (_a = services_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistHumiditySensor(this);
-    }
-    /** @inheritDoc */
-    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();
     }
-    /**
-     * Checks whether the battery level did change and if so fires the callbacks
-     */
-    checkForBatteryChange() {
-        const newLevel = this.battery;
-        if (newLevel == -1 || newLevel == this._lastBatteryLevel) {
-            return;
-        }
-        for (const cb of this._batteryLevelCallbacks) {
-            cb(new models_1.BatteryLevelChangeAction(this));
-        }
-        this._lastBatteryLevel = newLevel;
-    }
 }
 exports.ZigbeeSonoffTemp = ZigbeeSonoffTemp;

package/lib/server/services/dbo/postgreSqlPersist.js

@@ -433,7 +433,7 @@ values ('${device.id}', ${device.humidity}, '${new Date().toISOString()}');
     persistBatteryDevice(device) {
         this.query(`
 insert into hoffmation_schema."BatteryDeviceData" ("deviceID", "battery", "date")
-values ('${device.id}', ${utils_1.Utils.round(device.battery, 1)}, '${new Date().toISOString()}');
+values ('${device.id}', ${utils_1.Utils.round(device.batteryLevel, 1)}, '${new Date().toISOString()}');
     `);
     }
     /** @inheritDoc */

package/lib/server/services/utils/utils.js

@@ -85,9 +85,11 @@ class Utils {
             'interval',
             'timeouts',
             'callback',
+            'callbacks',
             'otaInfo',
             'precalculatedDistancesMap',
             'stateMap',
+            'jsonOmitKeys',
         ];
         keysToOmit.push(...additionalOmitKeys);
         const loweredOmitKeys = keysToOmit.map((key) => key.toLowerCase());
@@ -175,9 +177,11 @@ class Utils {
         return modMin < modMax ? modToCheck <= modMax && modToCheck >= modMin : modToCheck > modMin || modToCheck < modMax;
     }
     static deepOmit(obj, keysToOmit, topLevelOmitKeys, level = 1, currentKey = '') {
+        var _a;
         if (level > 10 && level < 20) {
             log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `DeepOmit Loop Level ${level} reached for ${currentKey}`);
         }
+        const combinedOmmitKeys = [...keysToOmit, ...((_a = obj === null || obj === void 0 ? void 0 : obj.jsonOmitKeys) !== null && _a !== void 0 ? _a : [])];
         // the inner function which will be called recursivley
         return lodash_1.default.transform(obj, (result, value, key) => {
             if (value === undefined || value === null) {
@@ -185,7 +189,7 @@ class Utils {
             }
             if (typeof key == 'string') {
                 const lowerKey = key.toLowerCase();
-                for (const checkKey of keysToOmit) {
+                for (const checkKey of combinedOmmitKeys) {
                     // if the key is in the index skip it
                     if (lowerKey.includes(checkKey)) {
                         return;

package/lib/server/services/victron/victron-device.d.ts

@@ -1,14 +1,18 @@
-import { DeviceCapability, DeviceInfo, DeviceType, iBatteryDevice, iEnergyManager, iExcessEnergyConsumer } from '../../devices';
-import { BatteryLevelChangeAction, LogLevel, VictronDeviceSettings } from '../../../models';
+import { Battery, DeviceCapability, DeviceInfo, DeviceType, iBatteryDevice, iEnergyManager, iExcessEnergyConsumer } from '../../devices';
+import { iJsonOmitKeys, LogLevel, VictronDeviceSettings } from '../../../models';
 import { LogDebugType } from '../log-service';
 import { VictronDeviceData, VictronMqttConnectionOptions, VictronMqttConsumer } from 'victron-mqtt-consumer';
-export declare class VictronDevice implements iEnergyManager, iBatteryDevice {
+export declare class VictronDevice implements iEnergyManager, iBatteryDevice, iJsonOmitKeys {
+    /** @inheritDoc */
+    readonly jsonOmitKeys: string[];
     /** @inheritDoc */
     readonly deviceCapabilities: DeviceCapability[];
     /** @inheritDoc */
     deviceType: DeviceType;
     /** @inheritDoc */
     readonly settings: VictronDeviceSettings;
+    /** @inheritDoc */
+    readonly battery: Battery;
     protected _info: DeviceInfo;
     private readonly _victronConsumer;
     private _excessEnergyConsumer;
@@ -18,19 +22,13 @@ export declare class VictronDevice implements iEnergyManager, iBatteryDevice {
     private _iDatabaseLoggerInterval;
     private _lastPersistenceCalculation;
     private _nextPersistEntry;
-    private _lastBatteryPersist;
-    private _lastBatteryLevel;
-    private _batteryLevelCallbacks;
     private _excessEnergy;
-    private _lastBatteryChangeReportMs;
     constructor(opts: VictronMqttConnectionOptions);
     /** @inheritDoc */
     get acBlocked(): boolean;
-    /** @inheritDoc */
-    get lastBatteryPersist(): number;
     get info(): DeviceInfo;
     /** @inheritDoc */
-    get battery(): number;
+    get batteryLevel(): number;
     get victronConsumer(): VictronMqttConsumer;
     get data(): VictronDeviceData;
     get excessEnergy(): number;
@@ -40,8 +38,6 @@ export declare class VictronDevice implements iEnergyManager, iBatteryDevice {
     get injectingWattage(): number;
     get drawingWattage(): number;
     get selfConsumingWattage(): number;
-    /** @inheritDoc */
-    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
     addExcessConsumer(device: iExcessEnergyConsumer): void;
     /** @inheritDoc */
     dispose(): void;
@@ -50,8 +46,6 @@ export declare class VictronDevice implements iEnergyManager, iBatteryDevice {
     loadDeviceSettings(): void;
     log(level: LogLevel, message: string, debugType?: LogDebugType): void;
     persistDeviceInfo(): void;
-    /** @inheritDoc */
-    persistBatteryDevice(): void;
     toJSON(): Partial<VictronDevice>;
     /**
      * Changes the grid set point of the Victron device, to the desired value.
@@ -63,5 +57,4 @@ export declare class VictronDevice implements iEnergyManager, iBatteryDevice {
     private turnOffAdditionalConsumer;
     private persist;
     private calculatePersistenceValues;
-    private checkForBatteryChange;
 }

package/lib/server/services/victron/victron-device.js

@@ -9,6 +9,8 @@ const victron_mqtt_consumer_1 = require("victron-mqtt-consumer");
 const time_callback_service_1 = require("../time-callback-service");
 class VictronDevice {
     constructor(opts) {
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['_victronConsumer', '_excessEnergyConsumer'];
         /** @inheritDoc */
         this.deviceCapabilities = [
             devices_1.DeviceCapability.energyManager,
@@ -16,16 +18,14 @@ class VictronDevice {
         ];
         /** @inheritDoc */
         this.deviceType = devices_1.DeviceType.Victron;
+        /** @inheritDoc */
+        this.battery = new devices_1.Battery(this);
         this._excessEnergyConsumer = [];
         this.blockDeviceChangeTime = -1;
         this._iCalculationInterval = null;
         this._iDatabaseLoggerInterval = null;
         this._lastPersistenceCalculation = utils_1.Utils.nowMS();
-        this._lastBatteryPersist = 0;
-        this._lastBatteryLevel = -1;
-        this._batteryLevelCallbacks = [];
         this._excessEnergy = 0;
-        this._lastBatteryChangeReportMs = 0;
         this.settings = new models_1.VictronDeviceSettings();
         this._info = new devices_1.DeviceInfo();
         this._info.fullName = 'Victron Device';
@@ -37,7 +37,9 @@ class VictronDevice {
         this.loadDeviceSettings();
         this._victronConsumer = new victron_mqtt_consumer_1.VictronMqttConsumer(opts);
         this._iCalculationInterval = utils_1.Utils.guardedInterval(() => {
-            this.checkForBatteryChange();
+            if (this.data.battery.soc) {
+                this.battery.level = this.data.battery.soc;
+            }
             this.calculateExcessEnergy();
         }, 5 * 1000, this);
         this._iDatabaseLoggerInterval = utils_1.Utils.guardedInterval(() => {
@@ -50,24 +52,20 @@ class VictronDevice {
         if (this.settings.hasBattery) {
             const hours = new Date().getHours();
             if (hours < 6 || hours > 18) {
-                return this.battery < this.settings.minimumNightTimeAcBatteryLevel;
+                return this.batteryLevel < this.settings.minimumNightTimeAcBatteryLevel;
             }
             if (hours < 10 || hours > 16) {
-                return this.battery < this.settings.minimumTransientTimeAcBatteryLevel;
+                return this.batteryLevel < this.settings.minimumTransientTimeAcBatteryLevel;
             }
-            return this.battery < this.settings.minimumDayTimeAcBatteryLevel;
+            return this.batteryLevel < this.settings.minimumDayTimeAcBatteryLevel;
         }
         return false;
     }
-    /** @inheritDoc */
-    get lastBatteryPersist() {
-        return this._lastBatteryPersist;
-    }
     get info() {
         return this._info;
     }
     /** @inheritDoc */
-    get battery() {
+    get batteryLevel() {
         const level = this.data.battery.soc;
         if (level == null) {
             this.log(models_1.LogLevel.Debug, 'No battery data available from Victron device.');
@@ -106,10 +104,6 @@ class VictronDevice {
         var _a;
         return Math.max((_a = this.victronConsumer.data.system.power) !== null && _a !== void 0 ? _a : 0, 0) - this.drawingWattage;
     }
-    /** @inheritDoc */
-    addBatteryLevelCallback(pCallback) {
-        this._batteryLevelCallbacks.push(pCallback);
-    }
     addExcessConsumer(device) {
         this._excessEnergyConsumer.push(device);
     }
@@ -158,27 +152,17 @@ class VictronDevice {
             (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
         }, 5000, this);
     }
-    /** @inheritDoc */
-    persistBatteryDevice() {
-        var _a;
-        const now = utils_1.Utils.nowMS();
-        if (this._lastBatteryPersist + 60000 > now) {
-            return;
-        }
-        (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistBatteryDevice(this);
-        this._lastBatteryPersist = now;
-    }
     toJSON() {
         return {
             ...{
-                battery: this.battery,
+                batteryLevel: this.batteryLevel,
                 acBlocked: this.acBlocked,
                 excessEnergy: this.excessEnergy,
                 drawingWattage: this.drawingWattage,
                 injectingWattage: this.injectingWattage,
                 selfConsumingWattage: this.selfConsumingWattage,
             },
-            ...utils_1.Utils.jsonFilter(this, ['_victronConsumer', '_excessEnergyConsumer']),
+            ...utils_1.Utils.jsonFilter(this, this.jsonOmitKeys),
         };
     }
     /**
@@ -200,11 +184,11 @@ class VictronDevice {
         let neededBatteryWattage = 0;
         const timeOfDay = time_callback_service_1.TimeCallbackService.dayType(new time_callback_service_1.SunTimeOffsets());
         if (this.settings.hasBattery && timeOfDay !== models_1.TimeOfDay.AfterSunset && timeOfDay !== models_1.TimeOfDay.Night) {
-            if (this.battery < 0) {
+            if (this.batteryLevel < 0) {
                 this.log(models_1.LogLevel.Debug, 'No battery data available from Victron device.');
                 return;
             }
-            neededBatteryWattage = ((1 - this.battery / 100.0) * this.settings.batteryCapacityWattage) / hoursTilSunset;
+            neededBatteryWattage = ((1 - this.batteryLevel / 100.0) * this.settings.batteryCapacityWattage) / hoursTilSunset;
             // Step 2: Calculate expected solar output
             const solarOutput = (_a = this.data.pvInverter.power) !== null && _a !== void 0 ? _a : 0;
             // Step 3: Calculate expected base consumption
@@ -213,22 +197,22 @@ class VictronDevice {
             this._excessEnergy = solarOutput - neededBatteryWattage - baseConsumption;
         }
         let isSocTooLow = false;
-        if (this.data.battery.dcPower !== null && this.battery > -1) {
+        if (this.data.battery.dcPower !== null && this.batteryLevel > -1) {
             if (timeOfDay === models_1.TimeOfDay.Night) {
-                isSocTooLow = this.battery < 50;
+                isSocTooLow = this.batteryLevel < 50;
             }
             else if (timeOfDay === models_1.TimeOfDay.AfterSunset) {
-                isSocTooLow = this.battery < 75;
+                isSocTooLow = this.batteryLevel < 75;
             }
             else if (hoursTilSunset > 4) {
-                isSocTooLow = this.battery < 70;
+                isSocTooLow = this.batteryLevel < 70;
             }
             else {
-                isSocTooLow = this.battery < 80;
+                isSocTooLow = this.batteryLevel < 80;
             }
         }
         // Whilst calculated spare energy is more precise, we don't mind using the battery as a buffer, if it is full enough.
-        if (this.data.battery.dcPower !== null && this.battery > -1 && !isSocTooLow) {
+        if (this.data.battery.dcPower !== null && this.batteryLevel > -1 && !isSocTooLow) {
             this._excessEnergy = this.settings.maximumBatteryDischargeWattage - Math.max(this.data.battery.dcPower, 0);
         }
         this.calculatePersistenceValues();
@@ -260,7 +244,7 @@ class VictronDevice {
         }
     }
     persist() {
-        this._nextPersistEntry.batteryLevel = this.battery / 100;
+        this._nextPersistEntry.batteryLevel = this.batteryLevel / 100;
         this._nextPersistEntry.batteryStoredKwH =
             (this._nextPersistEntry.batteryLevel * this.settings.batteryCapacityWattage) / 1000;
         const obj = JSON.parse(JSON.stringify(this._nextPersistEntry));
@@ -277,18 +261,5 @@ class VictronDevice {
         this._nextPersistEntry.selfConsumedKwH += utils_1.Utils.kWh(this.selfConsumingWattage, duration);
         this._lastPersistenceCalculation = now;
     }
-    checkForBatteryChange() {
-        const newLevel = this.battery;
-        if (newLevel == this._lastBatteryLevel &&
-            (this.settings.batteryReportingInterval < 0 ||
-                utils_1.Utils.nowMS() - this._lastBatteryChangeReportMs < this.settings.batteryReportingInterval * 60 * 1000)) {
-            return;
-        }
-        this._lastBatteryChangeReportMs = utils_1.Utils.nowMS();
-        for (const cb of this._batteryLevelCallbacks) {
-            cb(new models_1.BatteryLevelChangeAction(this));
-        }
-        this._lastBatteryLevel = newLevel;
-    }
 }
 exports.VictronDevice = VictronDevice;