hoffmation-base 3.0.2 → 3.1.0

package/lib/server/services/utils/utils.d.ts

@@ -1,37 +0,0 @@
-import { iPersist } from '../dbo';
-import { CatchEmResult } from './catchEmResult';
-import { iTimePair } from '../../config';
-import { RGB } from './RGB';
-export declare const DAYMS: number;
-export declare class Utils {
-    /**
-     * The persitence layer object
-     */
-    static dbo: iPersist | undefined;
-    static get anyDboActive(): boolean;
-    static get timeTilMidnight(): number;
-    static catchEm<T>(promise: Promise<T>): Promise<CatchEmResult<T>>;
-    static guardedFunction(func: (...args: unknown[]) => void, thisContext: unknown | undefined, additionalErrorMsg?: string): void;
-    static nowMS(): number;
-    static delay(ms: number): Promise<void>;
-    static guardedNewThread(func: (...args: unknown[]) => void, thisContext?: unknown | undefined): void;
-    static guardedTimeout(func: (...args: unknown[]) => void, time: number, thisContext?: unknown | undefined): NodeJS.Timeout;
-    static guardedInterval(func: (...args: unknown[]) => void, time: number, thisContext?: unknown | undefined, fireImmediate?: boolean): NodeJS.Timeout;
-    static nowString(): string;
-    static guard<T>(object: T | undefined | null): T & {};
-    static jsonFilter(object: object, additionalOmitKeys?: string[], topLevelOmmitKeys?: string[]): Partial<object>;
-    static testInitializeServices(): void;
-    static kWh(wattage: number, durationInMs: number): number;
-    static round(number: number, digits: number): number;
-    static roundDot5(number: number): number;
-    static beetweenDays(date: Date, startDay: number, endDay: number): boolean;
-    static nowTime(): iTimePair;
-    static dateByTimeSpan(hours: number, minutes: number, now?: Date): Date;
-    static positiveMod(number: number, mod: number): number;
-    static degreeInBetween(minDegree: number, maxDegree: number, degreeToCheck: number): boolean;
-    private static deepOmit;
-    static nextMatchingDate(hours?: number, minutes?: number, now?: Date): Date;
-    static timeWithinBorders(minimumHours: number, minimumMinutes: number, maxHours: number, maxMinutes: number, now?: Date): boolean;
-    static formatHex(hex: string): string | null;
-    static hexToRgb(color: string): RGB | null;
-}

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

@@ -1,286 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Utils = exports.DAYMS = void 0;
-const log_service_1 = require("../log-service");
-const models_1 = require("../../../models");
-const lodash_1 = __importDefault(require("lodash"));
-const Translation_1 = require("../Translation");
-const settings_service_1 = require("../settings-service");
-exports.DAYMS = 24 * 60 * 60 * 1000;
-class Utils {
-    static get anyDboActive() {
-        var _a;
-        return ((_a = settings_service_1.SettingsService.settings.persistence) === null || _a === void 0 ? void 0 : _a.postgreSql) !== undefined;
-    }
-    static get timeTilMidnight() {
-        return new Date(Utils.nowMS() + exports.DAYMS).setHours(0, 0, 0, 0) - Utils.nowMS();
-    }
-    static async catchEm(promise) {
-        return promise
-            .then((data) => ({
-            reason: null,
-            data,
-        }))
-            .catch((reason) => ({
-            reason,
-            data: null,
-        }));
-    }
-    static guardedFunction(func, thisContext, additionalErrorMsg) {
-        try {
-            if (thisContext) {
-                func.bind(thisContext)();
-            }
-            else {
-                func();
-            }
-        }
-        catch (e) {
-            const message = `Guarded Function failed: ${e.message}\n Stack: ${e.stack}`;
-            if (additionalErrorMsg) {
-                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `${message}\n${additionalErrorMsg}`);
-                return;
-            }
-            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Guarded Function failed: ${e.message}\n Stack: ${e.stack}`);
-        }
-    }
-    static nowMS() {
-        return new Date().getTime();
-    }
-    static delay(ms) {
-        return new Promise((res) => {
-            setTimeout(res, ms);
-        });
-    }
-    static guardedNewThread(func, thisContext) {
-        Utils.guardedTimeout(func, 1, thisContext);
-    }
-    static guardedTimeout(func, time, thisContext) {
-        return setTimeout(() => {
-            Utils.guardedFunction(func, thisContext);
-        }, time);
-    }
-    static guardedInterval(func, time, thisContext, fireImmediate = false) {
-        if (fireImmediate) {
-            Utils.guardedFunction(func, thisContext);
-        }
-        return setInterval(() => {
-            Utils.guardedFunction(func, thisContext);
-        }, time);
-    }
-    static nowString() {
-        const d = new Date();
-        return `${d.toLocaleTimeString('de-DE')}.${d.getMilliseconds()}`;
-    }
-    static guard(object) {
-        if (object === undefined) {
-            throw new Error('Guarded Value is undefined');
-        }
-        if (object === null) {
-            throw new Error('Guarded Value is null');
-        }
-        return object;
-    }
-    static jsonFilter(object, additionalOmitKeys = [], topLevelOmmitKeys = []) {
-        const keysToOmit = [
-            'timeout',
-            'interval',
-            'timeouts',
-            'callback',
-            'callbacks',
-            'otaInfo',
-            'precalculatedDistancesMap',
-            'stateMap',
-            'jsonOmitKeys',
-        ];
-        keysToOmit.push(...additionalOmitKeys);
-        const loweredOmitKeys = keysToOmit.map((key) => key.toLowerCase());
-        const loweredTopLevelOmitKeys = topLevelOmmitKeys.map((key) => key.toLowerCase());
-        return this.deepOmit(object, loweredOmitKeys, loweredTopLevelOmitKeys);
-    }
-    static testInitializeServices() {
-        log_service_1.ServerLogService.settings.logLevel = -1;
-        settings_service_1.SettingsService.initialize({
-            ioBrokerUrl: '',
-            timeSettings: {
-                nightEnd: {
-                    hours: 7,
-                    minutes: 30,
-                },
-                nightStart: {
-                    hours: 23,
-                    minutes: 30,
-                },
-            },
-            translationSettings: {
-                language: 'en',
-            },
-            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,
-            },
-        });
-        Translation_1.Res.initialize(settings_service_1.SettingsService.settings.translationSettings);
-    }
-    static kWh(wattage, durationInMs) {
-        return (wattage * durationInMs) / 3600000000.0;
-    }
-    static round(number, digits) {
-        const factor = Math.pow(10, digits);
-        return Math.round(number * factor) / factor;
-    }
-    static roundDot5(number) {
-        const x = Math.round(number * 10);
-        const roundToClosest5 = x % 5 >= 2.5 ? Math.floor(x / 5) * 5 + 5 : Math.floor(x / 5) * 5;
-        return roundToClosest5 / 10;
-    }
-    static beetweenDays(date, startDay, endDay) {
-        const yearStart = new Date(date.getTime());
-        yearStart.setMonth(0, 1);
-        const startDate = new Date(yearStart.getTime() + startDay * exports.DAYMS);
-        const endDate = new Date(yearStart.getTime() + endDay * exports.DAYMS);
-        return date <= endDate && date >= startDate;
-    }
-    static nowTime() {
-        const now = new Date();
-        return { hours: now.getHours(), minutes: now.getMinutes() };
-    }
-    static dateByTimeSpan(hours, minutes, now = new Date()) {
-        return new Date(new Date(now).setHours(hours, minutes));
-    }
-    static positiveMod(number, mod) {
-        return ((number % mod) + mod) % mod;
-    }
-    static degreeInBetween(minDegree, maxDegree, degreeToCheck) {
-        const modMin = this.positiveMod(minDegree, 360);
-        const modMax = this.positiveMod(maxDegree, 360);
-        const modToCheck = this.positiveMod(degreeToCheck, 360);
-        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) {
-                return;
-            }
-            if (typeof key == 'string') {
-                const lowerKey = key.toLowerCase();
-                for (const checkKey of combinedOmmitKeys) {
-                    // if the key is in the index skip it
-                    if (lowerKey.includes(checkKey)) {
-                        return;
-                    }
-                }
-                // transform to a new object
-                if (level === 1 && topLevelOmitKeys.includes(lowerKey)) {
-                    return;
-                }
-                if (lowerKey.endsWith('map')) {
-                    const newKey = lowerKey.replace('map', 'dict');
-                    const dict = {};
-                    const map = value;
-                    if (typeof map.keys !== 'function') {
-                        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Map ${currentKey}.${lowerKey} is not a map`);
-                        return;
-                    }
-                    for (const mapName of map.keys()) {
-                        dict[mapName] = lodash_1.default.isObject(map.get(mapName))
-                            ? this.deepOmit(map.get(mapName), keysToOmit, [], level + 1, `${currentKey}.${lowerKey}.${mapName}`)
-                            : map.get(mapName);
-                    }
-                    result[newKey] = dict;
-                    return;
-                }
-            }
-            if (typeof value.getMonth === 'function') {
-                result[key] = value.getTime();
-                return;
-            }
-            // if the key is an object run it through the inner function - omitFromObject
-            result[key] = lodash_1.default.isObject(value) ? this.deepOmit(value, keysToOmit, [], level + 1, `${currentKey}.${key}`) : value;
-        });
-    }
-    static nextMatchingDate(hours = 0, minutes = 0, now = new Date()) {
-        const todayOption = new Date(now.getTime());
-        todayOption.setHours(hours, minutes, 0, 0);
-        if (todayOption > now) {
-            // Today Option is in the future --> valid
-            return todayOption;
-        }
-        const todayMidnight = new Date(now.getTime());
-        todayMidnight.setHours(0, 0, 0, 0);
-        // 26 to guarantee matching next day even with time changes
-        const tomorowOption = new Date(todayMidnight.getTime() + 26 * 60 * 60 * 1000);
-        tomorowOption.setHours(hours, minutes, 0, 0);
-        return tomorowOption;
-    }
-    static timeWithinBorders(minimumHours, minimumMinutes, maxHours, maxMinutes, now = new Date()) {
-        if ((minimumHours != 0 || minimumMinutes != 0) && now < Utils.dateByTimeSpan(minimumHours, minimumMinutes, now)) {
-            return false;
-        }
-        else if ((maxHours != 0 || maxMinutes != 0) && now > Utils.dateByTimeSpan(maxHours, maxMinutes, now)) {
-            return false;
-        }
-        return true;
-    }
-    static formatHex(hex) {
-        if (hex === undefined || hex === null || hex === '') {
-            return null;
-        }
-        if (!hex.startsWith('#')) {
-            return `#${hex}`;
-        }
-        return hex;
-    }
-    static hexToRgb(color) {
-        let hex = Utils.formatHex(color);
-        if (hex === null) {
-            return null;
-        }
-        const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
-        hex = hex.replace(shorthandRegex, (_m, r, g, b) => {
-            return r + r + g + g + b + b;
-        });
-        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-        if (!result || result.length !== 4) {
-            return null;
-        }
-        const r = parseInt(result[1], 16);
-        const g = parseInt(result[2], 16);
-        const b = parseInt(result[3], 16);
-        if (isNaN(r) || isNaN(g) || isNaN(b)) {
-            return null;
-        }
-        return { r, g, b };
-    }
-}
-exports.Utils = Utils;

package/lib/server/services/victron/index.d.ts

@@ -1,2 +0,0 @@
-export * from './victron-device';
-export * from './victron-service';

package/lib/server/services/victron/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./victron-device"), exports);
-__exportStar(require("./victron-service"), exports);

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

@@ -1,60 +0,0 @@
-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, 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;
-    private blockDeviceChangeTime;
-    private _lastDeviceChange;
-    private _iCalculationInterval;
-    private _iDatabaseLoggerInterval;
-    private _lastPersistenceCalculation;
-    private _nextPersistEntry;
-    private _excessEnergy;
-    constructor(opts: VictronMqttConnectionOptions);
-    /** @inheritDoc */
-    get acBlocked(): boolean;
-    get info(): DeviceInfo;
-    /** @inheritDoc */
-    get batteryLevel(): number;
-    get victronConsumer(): VictronMqttConsumer;
-    get data(): VictronDeviceData;
-    get excessEnergy(): number;
-    get name(): string;
-    get customName(): string;
-    get id(): string;
-    get injectingWattage(): number;
-    get drawingWattage(): number;
-    get selfConsumingWattage(): number;
-    addExcessConsumer(device: iExcessEnergyConsumer): void;
-    /** @inheritDoc */
-    dispose(): void;
-    getReport(): string;
-    recalculatePowerSharing(): void;
-    loadDeviceSettings(): void;
-    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
-    persistDeviceInfo(): void;
-    toJSON(): Partial<VictronDevice>;
-    /**
-     * Changes the grid set point of the Victron device, to the desired value.
-     * @param setPoint - The desired watt point the system should aim for.
-     */
-    setGridSetPoint(setPoint: number): void;
-    private calculateExcessEnergy;
-    private turnOnAdditionalConsumer;
-    private turnOffAdditionalConsumer;
-    private persist;
-    private calculatePersistenceValues;
-}

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

@@ -1,265 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VictronDevice = void 0;
-const devices_1 = require("../../devices");
-const utils_1 = require("../utils");
-const models_1 = require("../../../models");
-const log_service_1 = require("../log-service");
-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,
-            devices_1.DeviceCapability.batteryDriven,
-        ];
-        /** @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._excessEnergy = 0;
-        this.settings = new models_1.VictronDeviceSettings();
-        this._info = new devices_1.DeviceInfo();
-        this._info.fullName = 'Victron Device';
-        this._info.customName = 'Victron';
-        this._info.allDevicesKey = 'victron';
-        devices_1.Devices.alLDevices['victron'] = this;
-        devices_1.Devices.energymanager = this;
-        this.persistDeviceInfo();
-        this.loadDeviceSettings();
-        this._victronConsumer = new victron_mqtt_consumer_1.VictronMqttConsumer(opts);
-        this._iCalculationInterval = utils_1.Utils.guardedInterval(() => {
-            if (this.data.battery.soc) {
-                this.battery.level = this.data.battery.soc;
-            }
-            this.calculateExcessEnergy();
-        }, 5 * 1000, this);
-        this._iDatabaseLoggerInterval = utils_1.Utils.guardedInterval(() => {
-            this.persist();
-        }, 15 * 60 * 1000, this);
-        this._nextPersistEntry = new models_1.EnergyCalculation(utils_1.Utils.nowMS());
-    }
-    /** @inheritDoc */
-    get acBlocked() {
-        if (this.settings.hasBattery) {
-            const hours = new Date().getHours();
-            if (hours < 6 || hours > 18) {
-                return this.batteryLevel < this.settings.minimumNightTimeAcBatteryLevel;
-            }
-            if (hours < 10 || hours > 16) {
-                return this.batteryLevel < this.settings.minimumTransientTimeAcBatteryLevel;
-            }
-            return this.batteryLevel < this.settings.minimumDayTimeAcBatteryLevel;
-        }
-        return false;
-    }
-    get info() {
-        return this._info;
-    }
-    /** @inheritDoc */
-    get batteryLevel() {
-        const level = this.data.battery.soc;
-        if (level == null) {
-            this.log(models_1.LogLevel.Debug, 'No battery data available from Victron device.');
-            return -1;
-        }
-        return level;
-    }
-    get victronConsumer() {
-        return this._victronConsumer;
-    }
-    get data() {
-        return this._victronConsumer.data;
-    }
-    get excessEnergy() {
-        return this._excessEnergy;
-    }
-    get name() {
-        return this.info.customName;
-    }
-    get customName() {
-        return this.info.customName;
-    }
-    get id() {
-        var _a;
-        return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `victron-${this.info.room}-${this.info.customName}`;
-    }
-    get injectingWattage() {
-        var _a;
-        return Math.min((_a = this.victronConsumer.data.grid.power) !== null && _a !== void 0 ? _a : 0, 0) * -1;
-    }
-    get drawingWattage() {
-        var _a;
-        return Math.max((_a = this.victronConsumer.data.grid.power) !== null && _a !== void 0 ? _a : 0, 0);
-    }
-    get selfConsumingWattage() {
-        var _a;
-        return Math.max((_a = this.victronConsumer.data.system.power) !== null && _a !== void 0 ? _a : 0, 0) - this.drawingWattage;
-    }
-    addExcessConsumer(device) {
-        this._excessEnergyConsumer.push(device);
-    }
-    /** @inheritDoc */
-    dispose() {
-        this._victronConsumer.disconnect();
-        if (this._iDatabaseLoggerInterval !== null) {
-            clearInterval(this._iDatabaseLoggerInterval);
-            this._iDatabaseLoggerInterval = null;
-        }
-        if (this._iCalculationInterval !== null) {
-            clearInterval(this._iCalculationInterval);
-            this._iCalculationInterval = null;
-        }
-    }
-    getReport() {
-        return '';
-    }
-    recalculatePowerSharing() {
-        this.calculateExcessEnergy();
-        // As some devices need time to start/shutdown we need to delay turning on/off more devices.
-        if (utils_1.Utils.nowMS() < this.blockDeviceChangeTime) {
-            return;
-        }
-        if (this.excessEnergy > this.settings.excessEnergyTurnOnThreshold) {
-            this.turnOnAdditionalConsumer();
-        }
-        else if (this.excessEnergy < this.settings.excessEnergyTurnOffThreshold) {
-            this.turnOffAdditionalConsumer();
-        }
-    }
-    loadDeviceSettings() {
-        this.settings.initializeFromDb(this);
-    }
-    log(level, message, debugType = log_service_1.LogDebugType.None) {
-        log_service_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
-            debugType: debugType,
-            room: '',
-            deviceId: this.name,
-            deviceName: this.name,
-        });
-    }
-    persistDeviceInfo() {
-        utils_1.Utils.guardedTimeout(() => {
-            var _a;
-            (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
-        }, 5000, this);
-    }
-    toJSON() {
-        return {
-            ...{
-                batteryLevel: this.batteryLevel,
-                acBlocked: this.acBlocked,
-                excessEnergy: this.excessEnergy,
-                drawingWattage: this.drawingWattage,
-                injectingWattage: this.injectingWattage,
-                selfConsumingWattage: this.selfConsumingWattage,
-            },
-            ...utils_1.Utils.jsonFilter(this, this.jsonOmitKeys),
-        };
-    }
-    /**
-     * Changes the grid set point of the Victron device, to the desired value.
-     * @param setPoint - The desired watt point the system should aim for.
-     */
-    setGridSetPoint(setPoint) {
-        this._victronConsumer.setGridSetPoint(setPoint);
-    }
-    calculateExcessEnergy() {
-        var _a;
-        this._excessEnergy = 0;
-        if (this.data == undefined) {
-            this.log(models_1.LogLevel.Debug, 'No data available from Victron device.');
-            return;
-        }
-        // Step 1: Calculate battery need
-        const hoursTilSunset = time_callback_service_1.TimeCallbackService.hoursTilSunset();
-        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.batteryLevel < 0) {
-                this.log(models_1.LogLevel.Debug, 'No battery data available from Victron device.');
-                return;
-            }
-            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
-            const baseConsumption = this.settings.normalBaseConsumptionWattage;
-            // Step 4: Combine to get currently excess energy
-            this._excessEnergy = solarOutput - neededBatteryWattage - baseConsumption;
-        }
-        let isSocTooLow = false;
-        if (this.data.battery.dcPower !== null && this.batteryLevel > -1) {
-            if (timeOfDay === models_1.TimeOfDay.Night) {
-                isSocTooLow = this.batteryLevel < 50;
-            }
-            else if (timeOfDay === models_1.TimeOfDay.AfterSunset) {
-                isSocTooLow = this.batteryLevel < 75;
-            }
-            else if (hoursTilSunset > 4) {
-                isSocTooLow = this.batteryLevel < 70;
-            }
-            else {
-                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.batteryLevel > -1 && !isSocTooLow) {
-            this._excessEnergy = this.settings.maximumBatteryDischargeWattage - Math.max(this.data.battery.dcPower, 0);
-        }
-        this.calculatePersistenceValues();
-    }
-    turnOnAdditionalConsumer() {
-        const result = utils_1.EnergyManagerUtils.turnOnAdditionalConsumer(this._excessEnergyConsumer, this._lastDeviceChange);
-        if (result == undefined) {
-            this._lastDeviceChange = undefined;
-            return;
-        }
-        if (result.newState) {
-            this.blockDeviceChangeTime = utils_1.Utils.nowMS() + result.device.energySettings.powerReactionTime;
-            result.device.log(models_1.LogLevel.Info, `Turning on, as we have ${this.excessEnergy}W to spare...`);
-            result.device.turnOnForExcessEnergy();
-            this._lastDeviceChange = result;
-        }
-    }
-    turnOffAdditionalConsumer() {
-        const result = utils_1.EnergyManagerUtils.turnOffAdditionalConsumer(this._excessEnergyConsumer, this._lastDeviceChange);
-        if (result == undefined) {
-            this._lastDeviceChange = undefined;
-            return;
-        }
-        if (!result.newState) {
-            this.blockDeviceChangeTime = utils_1.Utils.nowMS() + result.device.energySettings.powerReactionTime;
-            result.device.log(models_1.LogLevel.Info, "Turning off, as we don't have energy to spare...");
-            result.device.turnOffDueToMissingEnergy();
-            this._lastDeviceChange = result;
-        }
-    }
-    persist() {
-        this._nextPersistEntry.batteryLevel = this.batteryLevel / 100;
-        this._nextPersistEntry.batteryStoredKwH =
-            (this._nextPersistEntry.batteryLevel * this.settings.batteryCapacityWattage) / 1000;
-        const obj = JSON.parse(JSON.stringify(this._nextPersistEntry));
-        if (!models_1.EnergyCalculation.persist(obj, this._lastPersistenceCalculation, this.log.bind(this))) {
-            return;
-        }
-        this._nextPersistEntry = new models_1.EnergyCalculation(this._lastPersistenceCalculation);
-    }
-    calculatePersistenceValues() {
-        const now = utils_1.Utils.nowMS();
-        const duration = now - this._lastPersistenceCalculation;
-        this._nextPersistEntry.drawnKwH += utils_1.Utils.kWh(this.drawingWattage, duration);
-        this._nextPersistEntry.injectedKwH += utils_1.Utils.kWh(this.injectingWattage, duration);
-        this._nextPersistEntry.selfConsumedKwH += utils_1.Utils.kWh(this.selfConsumingWattage, duration);
-        this._lastPersistenceCalculation = now;
-    }
-}
-exports.VictronDevice = VictronDevice;

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

@@ -1,11 +0,0 @@
-import { iVictronSettings } from '../../config';
-import { VictronDeviceData } from 'victron-mqtt-consumer';
-export declare class VictronService {
-    private static _settings;
-    private static _victronDevice;
-    static get settings(): iVictronSettings | undefined;
-    static get data(): VictronDeviceData | undefined;
-    private static _active;
-    static get active(): boolean;
-    static initialize(settings?: iVictronSettings): void;
-}