hoffmation-base 3.0.0-alpha.76 → 3.0.0-alpha.78

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

@@ -51,6 +51,7 @@ class DeviceCluster {
             case deviceType_1.DeviceType.HmIpRoll:
             case deviceType_1.DeviceType.ZigbeeIlluShutter:
             case deviceType_1.DeviceType.ZigbeeUbisysShutter:
+            case deviceType_1.DeviceType.VeluxShutter:
                 clusterTypes.push(device_cluster_type_1.DeviceClusterType.Shutter);
                 break;
             case deviceType_1.DeviceType.ZigbeeSonoffTemp:

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

@@ -46,6 +46,7 @@ export declare enum DeviceType {
     SmartGardenValve = 601,
     SmartGardenMower = 602,
     SmartGardenSensor = 603,
+    VeluxShutter = 701,
     WledDevice = 1001,
     GoveeLed = 1002,
     Daikin = 2001,

package/lib/server/devices/deviceType.js

@@ -50,6 +50,7 @@ var DeviceType;
     DeviceType[DeviceType["SmartGardenValve"] = 601] = "SmartGardenValve";
     DeviceType[DeviceType["SmartGardenMower"] = 602] = "SmartGardenMower";
     DeviceType[DeviceType["SmartGardenSensor"] = 603] = "SmartGardenSensor";
+    DeviceType[DeviceType["VeluxShutter"] = 701] = "VeluxShutter";
     DeviceType[DeviceType["WledDevice"] = 1001] = "WledDevice";
     DeviceType[DeviceType["GoveeLed"] = 1002] = "GoveeLed";
     DeviceType[DeviceType["Daikin"] = 2001] = "Daikin";

package/lib/server/devices/deviceUpdater.js

@@ -48,6 +48,14 @@ class DeviceUpdater {
             classifier = devices_1.Devices.IDENTIFIER_SMART_GARDEN;
             devId = idSplit[3].replace(/-2D/g, '-');
         }
+        else if (idSplit[0] == devices_1.Devices.IDENTIFIER_VELUX) {
+            if (idSplit[1] === 'admin' || idSplit[2].indexOf('DEVICE') !== 0) {
+                // This is no update for a velux device
+                return;
+            }
+            classifier = devices_1.Devices.IDENTIFIER_VELUX;
+            devId = idSplit[3];
+        }
         const allDevicesKey = `${classifier}-${devId}`;
         const device = services_1.API.getDevice(allDevicesKey, false);
         if (typeof device === 'undefined' || device.update === undefined) {

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

@@ -35,6 +35,10 @@ export declare class Devices {
      * A constant for the identifier of SmartGarden devices.
      */
     static readonly IDENTIFIER_SMART_GARDEN: string;
+    /**
+     * A constant for the identifier of Velux Adapter devices.
+     */
+    static readonly IDENTIFIER_VELUX: string;
     /**
      * A Map containing all devices
      */
@@ -65,6 +69,7 @@ export declare class Devices {
     private static processShellyDevice;
     private static processTuyaDevice;
     private static processZigbeeDevice;
+    private static processVeluxDevice;
     private static processSmartGardenDevice;
     private static processWledDevice;
     private static processHMIPDevice;

package/lib/server/devices/devices.js

@@ -13,6 +13,7 @@ const DeviceCapability_1 = require("./DeviceCapability");
 const shelly_1 = require("./shelly");
 const tuya_1 = require("./tuya");
 const smartGarden_1 = require("./smartGarden");
+const velux_1 = require("./velux");
 class Devices {
     constructor(pDeviceData, pRoomImportEnforcer, config) {
         var _a;
@@ -21,14 +22,17 @@ class Devices {
         services_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Constructing devices now');
         for (const cID in pDeviceData) {
             const cDevConf = pDeviceData[cID];
-            if (!cDevConf.common ||
-                !cDevConf.common.name ||
-                typeof cDevConf.common.name === 'object' ||
-                !cDevConf.type ||
-                cDevConf.type === 'channel') {
+            if (!cDevConf.common || !cDevConf.common.name || typeof cDevConf.common.name === 'object' || !cDevConf.type) {
                 continue;
             }
             const cName = cDevConf.common.name;
+            if (cDevConf.type === 'channel') {
+                // Velux has the name in the root channel of a device
+                if (cName.indexOf('00-Velux') === 0) {
+                    Devices.processVeluxDevice(cDevConf);
+                }
+                continue;
+            }
             if (cName.indexOf('00-HmIP') === 0) {
                 Devices.processHMIPDevice(cDevConf);
             }
@@ -228,6 +232,9 @@ class Devices {
         }
         Devices.alLDevices[fullName] = d;
     }
+    static processVeluxDevice(cDevConf) {
+        velux_1.VeluxService.processVeluxDevice(cDevConf);
+    }
     static processSmartGardenDevice(cDevConf) {
         smartGarden_1.SmartGardenService.processSmartGardenDevice(cDevConf);
     }
@@ -338,6 +345,10 @@ Devices.IDENTIFIER_WLED = 'wled';
  * A constant for the identifier of SmartGarden devices.
  */
 Devices.IDENTIFIER_SMART_GARDEN = 'smartgarden';
+/**
+ * A constant for the identifier of Velux Adapter devices.
+ */
+Devices.IDENTIFIER_VELUX = 'klf200';
 /**
  * A Map containing all devices
  */

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

@@ -13,6 +13,7 @@ export * from './shelly/index';
 export * from './smartGarden/index';
 export * from './tuya/index';
 export * from './tv/index';
+export * from './velux/index';
 export * from './zigbee/index';
 export * from './device-cluster';
 export * from './device-cluster-type';

package/lib/server/devices/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./shelly/index"), exports);
 __exportStar(require("./smartGarden/index"), exports);
 __exportStar(require("./tuya/index"), exports);
 __exportStar(require("./tv/index"), exports);
+__exportStar(require("./velux/index"), exports);
 __exportStar(require("./zigbee/index"), exports);
 __exportStar(require("./device-cluster"), exports);
 __exportStar(require("./device-cluster-type"), exports);

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

@@ -0,0 +1,4 @@
+export { VeluxDevice } from './veluxDevice';
+export { VeluxShutter } from './veluxShutter';
+export { VeluxDeviceRegistrationInfo } from './veluxDeviceRegistrationInfo';
+export { VeluxService } from './veluxService';

package/lib/server/devices/velux/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxService = exports.VeluxDeviceRegistrationInfo = exports.VeluxShutter = exports.VeluxDevice = void 0;
+var veluxDevice_1 = require("./veluxDevice");
+Object.defineProperty(exports, "VeluxDevice", { enumerable: true, get: function () { return veluxDevice_1.VeluxDevice; } });
+var veluxShutter_1 = require("./veluxShutter");
+Object.defineProperty(exports, "VeluxShutter", { enumerable: true, get: function () { return veluxShutter_1.VeluxShutter; } });
+var veluxDeviceRegistrationInfo_1 = require("./veluxDeviceRegistrationInfo");
+Object.defineProperty(exports, "VeluxDeviceRegistrationInfo", { enumerable: true, get: function () { return veluxDeviceRegistrationInfo_1.VeluxDeviceRegistrationInfo; } });
+var veluxService_1 = require("./veluxService");
+Object.defineProperty(exports, "VeluxService", { enumerable: true, get: function () { return veluxService_1.VeluxService; } });

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

@@ -0,0 +1,13 @@
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+import { iDisposable } from '../../services';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { DeviceType } from '../deviceType';
+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/server/devices/velux/veluxDevice.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxDevice = void 0;
+const IoBrokerBaseDevice_1 = require("../IoBrokerBaseDevice");
+const DeviceCapability_1 = require("../DeviceCapability");
+const models_1 = require("../../../models");
+class VeluxDevice extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        this._lastUpdate = new Date(0);
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.batteryDriven);
+    }
+    get lastUpdate() {
+        return this._lastUpdate;
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false, pOverride = false) {
+        this.log(models_1.LogLevel.DeepTrace, `Velux: ${initial ? 'Initiales ' : ''}Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        if (!pOverride) {
+            this.log(models_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/server/devices/velux/veluxDeviceRegistrationInfo.d.ts

@@ -0,0 +1,9 @@
+import { DeviceType } from '../deviceType';
+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/server/devices/velux/veluxDeviceRegistrationInfo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxDeviceRegistrationInfo = void 0;
+class VeluxDeviceRegistrationInfo {
+    constructor(deviceType, deviceId, deviceName, room, roomIndex) {
+        this.deviceType = deviceType;
+        this.deviceId = deviceId;
+        this.deviceName = deviceName;
+        this.room = room;
+        this.roomIndex = roomIndex;
+    }
+}
+exports.VeluxDeviceRegistrationInfo = VeluxDeviceRegistrationInfo;

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

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

package/lib/server/devices/velux/veluxService.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeluxService = void 0;
+const models_1 = require("../../../models");
+const services_1 = require("../../services");
+const IoBrokerDeviceInfo_1 = require("../IoBrokerDeviceInfo");
+const deviceType_1 = require("../deviceType");
+const devices_1 = require("../devices");
+const veluxShutter_1 = require("./veluxShutter");
+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) {
+            services_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Velux Device ${devName} not registered`);
+            return;
+        }
+        const ioBrokerDeviceInfo = new IoBrokerDeviceInfo_1.IoBrokerDeviceInfo(cDevConf, registrationInfo.deviceId, deviceType_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 deviceType_1.DeviceType.VeluxShutter:
+                d = new veluxShutter_1.VeluxShutter(ioBrokerDeviceInfo);
+                break;
+            default:
+                services_1.ServerLogService.writeLog(models_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/server/devices/velux/veluxShutter.d.ts

@@ -0,0 +1,27 @@
+import { Window } from '../groups';
+import { ShutterSetLevelCommand, ShutterSettings } from '../../../models';
+import { iShutter } from '../baseDeviceInterfaces';
+import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
+import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
+import { VeluxDevice } from './veluxDevice';
+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(): Window | undefined;
+    set window(value: Window | 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/server/devices/velux/veluxShutter.js

@@ -0,0 +1,122 @@
+"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 deviceType_1 = require("../deviceType");
+const services_1 = require("../../services");
+const models_1 = require("../models");
+const models_2 = require("../../../models");
+const lodash_1 = __importDefault(require("lodash"));
+const DeviceCapability_1 = require("../DeviceCapability");
+const veluxDevice_1 = require("./veluxDevice");
+class VeluxShutter extends veluxDevice_1.VeluxDevice {
+    constructor(pInfo) {
+        var _a;
+        super(pInfo, deviceType_1.DeviceType.VeluxShutter);
+        /** @inheritDoc */
+        this.settings = new models_2.ShutterSettings();
+        this._firstCommandRecieved = false;
+        this._setLevel = -1;
+        this._setLevelTime = -1;
+        this._currentLevel = -1;
+        this.deviceCapabilities.push(DeviceCapability_1.DeviceCapability.shutter);
+        this._setLevelSwitchID = `${this.info.fullID}.targetPosition`;
+        (_a = services_1.Utils.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 models_2.WindowSetDesiredPositionCommand(models_2.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(models_2.LogLevel.DeepTrace, `Rollo Update : ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[4]) {
+            case 'targetPosition':
+                this.setCurrentLevel(state.val, true);
+                break;
+        }
+    }
+    persist() {
+        var _a;
+        (_a = services_1.Utils.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(models_2.LogLevel.Debug, `Skipped initial Rollo to ${targetLevel} as we recieved a command already`);
+            return;
+        }
+        if (this.currentLevel === targetLevel && !command.isForceAction) {
+            this.log(models_2.LogLevel.Debug, `Skip Rollo command to Position ${targetLevel} as this is the current one, commandLog: ${command.logMessage}`, services_1.LogDebugType.SkipUnchangedRolloPosition);
+            return;
+        }
+        if (this._setLevelSwitchID === '') {
+            this.log(models_2.LogLevel.Error, 'Keine Switch ID bekannt.');
+            return;
+        }
+        if (!this.checkIoConnection(true)) {
+            return;
+        }
+        this.log(models_2.LogLevel.Debug, command.logMessage);
+        if (this._window !== undefined) {
+            if (this._window.griffeInPosition(models_1.WindowPosition.offen) > 0 && command.level < 100) {
+                if (!command.skipOpenWarning) {
+                    this.log(models_2.LogLevel.Alert, 'Not closing the shutter, as the window is open!');
+                }
+                return;
+            }
+            if (this._window.griffeInPosition(models_1.WindowPosition.kipp) > 0 && targetLevel < 50) {
+                targetLevel = 50;
+                if (!command.skipOpenWarning) {
+                    this.log(models_2.LogLevel.Alert, 'Not closing the shutter, as the window is half open!');
+                }
+            }
+        }
+        this._setLevel = targetLevel;
+        this.log(models_2.LogLevel.Debug, `Fahre Rollo auf Position ${targetLevel}`);
+        this.setState(this._setLevelSwitchID, targetLevel);
+    }
+    toJSON() {
+        return lodash_1.default.omit(super.toJSON(), ['_window']);
+    }
+    setCurrentLevel(value, initial = false) {
+        if (value !== this._setLevel && services_1.Utils.nowMS() - this._setLevelTime < 60 * 10000) {
+            value = this._setLevel;
+        }
+        if (value !== this._currentLevel && this._window && !initial) {
+            services_1.Utils.guardedNewThread(() => {
+                var _a;
+                (_a = this._window) === null || _a === void 0 ? void 0 : _a.rolloPositionChange(new models_2.ShutterPositionChangedAction(this, value));
+            }, this);
+            this.persist();
+        }
+        this._currentLevel = value;
+    }
+}
+exports.VeluxShutter = VeluxShutter;

package/lib/server/services/ShutterService.js

@@ -46,6 +46,7 @@ class ShutterService {
             const d = devices_1.Devices.alLDevices[dID];
             if (d.deviceType === devices_1.DeviceType.HmIpRoll ||
                 d.deviceType === devices_1.DeviceType.ZigbeeIlluShutter ||
+                d.deviceType === devices_1.DeviceType.VeluxShutter ||
                 d.deviceType === devices_1.DeviceType.ZigbeeUbisysShutter) {
                 rollos.push(d);
             }