hoffmation-base 3.0.3 → 3.1.0

package/lib/devices/unifi/unifi-protect.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiProtect = void 0;
+const unifi_protect_1 = require("unifi-protect");
+const enums_1 = require("../../enums");
+const logging_1 = require("../../logging");
+class UnifiProtect {
+    constructor(settings) {
+        this.unifiLogger = new UnifiLogger();
+        this._deviceStates = new Map();
+        this._idMap = new Map();
+        this._api = new unifi_protect_1.ProtectApi(this.unifiLogger);
+        this._api
+            .login(settings.nvrAddress, settings.username, settings.password)
+            .then((_loggedIn) => {
+            this.initialize();
+        })
+            .catch((error) => {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Unifi-Protect: Login failed: ${error}`);
+        });
+    }
+    dispose() {
+        this._api.logout();
+    }
+    static addDevice(camera) {
+        this.ownCameras.set(camera.unifiCameraName, camera);
+    }
+    async initialize() {
+        this.unifiLogger.info('Unifi-Protect: Login successful');
+        const bootstrap = await this._api.getBootstrap();
+        if (!bootstrap || !this._api.bootstrap) {
+            this.unifiLogger.error('Unifi-Protect: Bootstrap failed');
+            return;
+        }
+        const info = this._api.bootstrap;
+        for (const camera of info.cameras) {
+            this.initializeCamera(camera);
+        }
+        this._api.on('message', this.onMessage.bind(this));
+    }
+    onMessage(packet) {
+        var _a, _b;
+        const payload = packet.payload;
+        switch (packet.header.modelKey) {
+            case 'nvr':
+                break;
+            default:
+                // Lookup the device.
+                let id = packet.header.id;
+                if (packet.header.action === 'add') {
+                    id = (_a = packet.payload.camera) !== null && _a !== void 0 ? _a : packet.payload.cameraId;
+                }
+                const ownName = this._idMap.get(id);
+                if (!ownName) {
+                    break;
+                }
+                const ownCamera = UnifiProtect.ownCameras.get(ownName);
+                if (ownCamera !== undefined) {
+                    ownCamera.update(packet);
+                    break;
+                }
+                break;
+        }
+        // Update the internal list we maintain.
+        if (packet.header.action === 'update') {
+            this._deviceStates.set(packet.header.id, Object.assign((_b = this._deviceStates.get(packet.header.id)) !== null && _b !== void 0 ? _b : {}, payload));
+        }
+    }
+    initializeCamera(data) {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, `Unifi-Protect: Camera ${data.name} initialized`);
+        if (!UnifiProtect.ownCameras.has(data.name)) {
+            return;
+        }
+        const camera = UnifiProtect.ownCameras.get(data.name);
+        camera.initialize(data);
+        this._idMap.set(data.id, data.name);
+    }
+}
+exports.UnifiProtect = UnifiProtect;
+/**
+ * Mapping for own devices
+ */
+UnifiProtect.ownCameras = new Map();
+class UnifiLogger {
+    debug(message, ..._parameters) {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Debug, message, {
+            source: enums_1.LogSource.UnifiProtect,
+        });
+    }
+    error(message, ..._parameters) {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, message, {
+            source: enums_1.LogSource.UnifiProtect,
+        });
+    }
+    info(message, ..._parameters) {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Info, message, {
+            source: enums_1.LogSource.UnifiProtect,
+        });
+    }
+    warn(message, ..._parameters) {
+        logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, message, {
+            source: enums_1.LogSource.UnifiProtect,
+        });
+    }
+}

package/lib/devices/velux/veluxDevice.d.ts

@@ -0,0 +1,13 @@
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+import { iDisposable } from '../../interfaces';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { DeviceType } from '../../enums';
+export declare class VeluxDevice extends IoBrokerBaseDevice implements iDisposable {
+    private _lastUpdate;
+    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    get lastUpdate(): Date;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+}

package/lib/devices/velux/veluxDevice.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxDevice = void 0;
+const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
+const enums_1 = require("../../enums");
+class VeluxDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        this._lastUpdate = new Date(0);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.batteryDriven);
+    }
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, pOverride = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Velux: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        if (!pOverride) {
+            this.log(enums_1.LogLevel.Warn, `Keine Update Überschreibung:\n\tID: ${idSplit.join('.')}\n\tData: ${JSON.stringify(state)}`);
+        }
+        const stateLastUpdate = new Date(state.ts);
+        if (stateLastUpdate > this._lastUpdate) {
+            this._lastUpdate = stateLastUpdate;
+        }
+        if (idSplit.length < 5) {
+            return;
+        }
+        const stateName = idSplit[4];
+        this.stateMap.set(stateName, state);
+        const individualCallbacks = this.individualStateCallbacks.get(stateName);
+        if (individualCallbacks !== undefined) {
+            for (const cb of individualCallbacks) {
+                cb(state.val);
+            }
+        }
+    }
+    /** @inheritDoc */
+    dispose() {
+        // Nothing yet
+    }
+}
+exports.VeluxDevice = VeluxDevice;

package/lib/devices/velux/veluxDeviceRegistrationInfo.d.ts

@@ -0,0 +1,9 @@
+import { DeviceType } from '../../enums';
+export declare class VeluxDeviceRegistrationInfo {
+    readonly deviceType: DeviceType;
+    readonly deviceId: string;
+    readonly deviceName: string;
+    readonly room: string;
+    readonly roomIndex: number;
+    constructor(deviceType: DeviceType, deviceId: string, deviceName: string, room: string, roomIndex: number);
+}

package/lib/devices/velux/veluxService.d.ts

@@ -0,0 +1,7 @@
+import { VeluxDeviceRegistrationInfo } from './veluxDeviceRegistrationInfo';
+import { iDeviceConfig } from '../../interfaces/iDeviceConfig';
+export declare class VeluxService {
+    private static readonly _registeredDevices;
+    static preRegisterDevice(devName: string, registrationInfo: VeluxDeviceRegistrationInfo): void;
+    static processVeluxDevice(cDevConf: iDeviceConfig): void;
+}

package/lib/devices/velux/veluxService.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxService = void 0;
+const devices_1 = require("../devices");
+const enums_1 = require("../../enums");
+const logging_1 = require("../../logging");
+const veluxShutter_1 = require("./veluxShutter");
+const IoBrokerDeviceInfo_1 = require("../IoBrokerDeviceInfo");
+class VeluxService {
+    static preRegisterDevice(devName, registrationInfo) {
+        this._registeredDevices.set(devName, registrationInfo);
+    }
+    static processVeluxDevice(cDevConf) {
+        var _a;
+        const devName = (_a = cDevConf.common) === null || _a === void 0 ? void 0 : _a.name;
+        if (!devName || typeof devName !== 'string') {
+            return;
+        }
+        const registrationInfo = this._registeredDevices.get(devName);
+        if (!registrationInfo) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Error, `Velux Device ${devName} not registered`);
+            return;
+        }
+        const ioBrokerDeviceInfo = new IoBrokerDeviceInfo_1.IoBrokerDeviceInfo(cDevConf, registrationInfo.deviceId, enums_1.DeviceType[registrationInfo.deviceType], registrationInfo.room, registrationInfo.roomIndex);
+        const fullName = `${devices_1.Devices.IDENTIFIER_VELUX}-${ioBrokerDeviceInfo.devID}`;
+        if (typeof devices_1.Devices.alLDevices[fullName] !== 'undefined') {
+            return;
+        }
+        ioBrokerDeviceInfo.allDevicesKey = fullName;
+        let d;
+        switch (registrationInfo.deviceType) {
+            case enums_1.DeviceType.VeluxShutter:
+                d = new veluxShutter_1.VeluxShutter(ioBrokerDeviceInfo);
+                break;
+            default:
+                logging_1.ServerLogService.writeLog(enums_1.LogLevel.Warn, `No Velux Device Type for ${registrationInfo.deviceType} defined`);
+                return;
+        }
+        devices_1.Devices.alLDevices[fullName] = d;
+    }
+}
+exports.VeluxService = VeluxService;
+VeluxService._registeredDevices = new Map();

package/lib/devices/velux/veluxShutter.d.ts

@@ -0,0 +1,27 @@
+import { VeluxDevice } from './veluxDevice';
+import { iShutter, iWindow } from '../../interfaces';
+import { ShutterSettings } from '../../settingsObjects';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { ShutterSetLevelCommand } from '../../command';
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+export declare class VeluxShutter extends VeluxDevice implements iShutter {
+    /** @inheritDoc */
+    settings: ShutterSettings;
+    private readonly _setLevelSwitchID;
+    private _firstCommandRecieved;
+    private _setLevel;
+    private _setLevelTime;
+    private _currentLevel;
+    private _window?;
+    constructor(pInfo: IoBrokerDeviceInfo);
+    get currentLevel(): number;
+    get window(): iWindow | undefined;
+    set window(value: iWindow | undefined);
+    get desiredWindowShutterLevel(): number;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    persist(): void;
+    setLevel(command: ShutterSetLevelCommand): void;
+    toJSON(): Partial<IoBrokerBaseDevice>;
+    private setCurrentLevel;
+}

package/lib/devices/velux/veluxShutter.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxShutter = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const veluxDevice_1 = require("./veluxDevice");
+const settingsObjects_1 = require("../../settingsObjects");
+const enums_1 = require("../../enums");
+const action_1 = require("../../action");
+const command_1 = require("../../command");
+const utils_1 = require("../../utils");
+class VeluxShutter extends veluxDevice_1.VeluxDevice {
+    constructor(pInfo) {
+        var _a;
+        super(pInfo, enums_1.DeviceType.VeluxShutter);
+        /** @inheritDoc */
+        this.settings = new settingsObjects_1.ShutterSettings();
+        this._firstCommandRecieved = false;
+        this._setLevel = -1;
+        this._setLevelTime = -1;
+        this._currentLevel = -1;
+        this.deviceCapabilities.push(enums_1.DeviceCapability.shutter);
+        this._setLevelSwitchID = `${this.info.fullID}.targetPosition`;
+        (_a = this.dbo) === null || _a === void 0 ? void 0 : _a.getLastDesiredPosition(this).then((val) => {
+            var _a;
+            if (val.desiredPosition === -1) {
+                return;
+            }
+            (_a = this._window) === null || _a === void 0 ? void 0 : _a.setDesiredPosition(new command_1.WindowSetDesiredPositionCommand(enums_1.CommandSource.Automatic, val.desiredPosition, 'Found persisted last desired position in DB'));
+        });
+    }
+    get currentLevel() {
+        if (this._setLevel !== -1 && this._currentLevel !== this._setLevel) {
+            return this._setLevel;
+        }
+        return this._currentLevel;
+    }
+    get window() {
+        return this._window;
+    }
+    set window(value) {
+        this._window = value;
+    }
+    get desiredWindowShutterLevel() {
+        if (this._window === undefined) {
+            return -1;
+        }
+        return this._window.desiredPosition;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        this.log(enums_1.LogLevel.DeepTrace, `Rollo Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[4]) {
+            case 'currentPosition':
+                this.setCurrentLevel(state.val, true);
+                break;
+        }
+    }
+    persist() {
+        var _a;
+        (_a = this.dbo) === null || _a === void 0 ? void 0 : _a.persistShutter(this);
+    }
+    setLevel(command) {
+        let targetLevel = command.level;
+        if (!this._firstCommandRecieved && !command.isInitial) {
+            this._firstCommandRecieved = true;
+        }
+        if (this._firstCommandRecieved && command.isInitial) {
+            this.log(enums_1.LogLevel.Debug, `Skipped initial Rollo to ${targetLevel} as we recieved a command already`);
+            return;
+        }
+        if (this.currentLevel === targetLevel && !command.isForceAction) {
+            this.log(enums_1.LogLevel.Debug, `Skip Rollo command to Position ${targetLevel} as this is the current one, commandLog: ${command.logMessage}`, enums_1.LogDebugType.SkipUnchangedRolloPosition);
+            return;
+        }
+        if (this._setLevelSwitchID === '') {
+            this.log(enums_1.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        if (!this.checkIoConnection(true)) {
+            return;
+        }
+        this.log(enums_1.LogLevel.Debug, command.logMessage);
+        if (this._window !== undefined) {
+            if (this._window.griffeInPosition(enums_1.WindowPosition.open) > 0 && command.level < 100) {
+                if (!command.skipOpenWarning) {
+                    this.log(enums_1.LogLevel.Alert, 'Not closing the shutter, as the window is open!');
+                }
+                return;
+            }
+            if (this._window.griffeInPosition(enums_1.WindowPosition.tilted) > 0 && targetLevel < 50) {
+                targetLevel = 50;
+                if (!command.skipOpenWarning) {
+                    this.log(enums_1.LogLevel.Alert, 'Not closing the shutter, as the window is half open!');
+                }
+            }
+        }
+        this._setLevel = targetLevel;
+        this.log(enums_1.LogLevel.Debug, `Fahre Rollo auf Position ${targetLevel}`);
+        // Level is inverted for Velux Adapter (100 = 0, 0 = 100, 25 = 75, etc.)
+        this.setState(this._setLevelSwitchID, Math.abs(targetLevel - 100));
+    }
+    toJSON() {
+        return lodash_1.default.omit(super.toJSON(), ['_window']);
+    }
+    setCurrentLevel(value, initial = false) {
+        let correctedValue = Math.abs(value - 100);
+        if (correctedValue !== this._setLevel && utils_1.Utils.nowMS() - this._setLevelTime < 60 * 10000) {
+            correctedValue = this._setLevel;
+        }
+        if (correctedValue !== this._currentLevel && this._window && !initial) {
+            utils_1.Utils.guardedNewThread(() => {
+                var _a;
+                (_a = this._window) === null || _a === void 0 ? void 0 : _a.rolloPositionChange(new action_1.ShutterPositionChangedAction(this, correctedValue));
+            }, this);
+            this.persist();
+        }
+        this._currentLevel = correctedValue;
+    }
+}
+exports.VeluxShutter = VeluxShutter;

package/lib/devices/victron/index.d.ts

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

package/lib/devices/victron/index.js

@@ -0,0 +1,20 @@
+"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 });
+exports.VictronService = void 0;
+__exportStar(require("./victron-device"), exports);
+var victron_service_1 = require("./victron-service");
+Object.defineProperty(exports, "VictronService", { enumerable: true, get: function () { return victron_service_1.VictronService; } });

package/lib/devices/victron/victron-device.d.ts

@@ -0,0 +1,62 @@
+import { iBatteryDevice, iEnergyManager, iExcessEnergyConsumer, iJsonOmitKeys } from '../../interfaces';
+import { DeviceCapability, DeviceType, LogDebugType, LogLevel } from '../../enums';
+import { VictronDeviceSettings } from '../../settingsObjects';
+import { Battery } from '../sharedFunctions';
+import { DeviceInfo } from '../DeviceInfo';
+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;
+}