hoffmation-base 3.0.3 → 3.1.0

package/lib/devices/dachs/lib/dachsHttpClient.js

@@ -0,0 +1,186 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DachsHttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const ReadKeyList_1 = __importDefault(require("./ReadKeyList"));
+const _ = __importStar(require("lodash"));
+const keyTemplates_1 = __importDefault(require("./keyTemplates"));
+const http = __importStar(require("node:http"));
+const https = __importStar(require("node:https"));
+const enums_1 = require("../../../enums");
+/**
+ * axios HTTP Client Class
+ * - with some prepared fetch functions for data
+ * @author Trickfilm400
+ * @version 1
+ * @class
+ */
+class DachsHttpClient {
+    constructor(options, _logger) {
+        var _a;
+        this._logger = _logger;
+        this.options = options;
+        //combine parameter to baseUrl
+        //check http prefix
+        axios_1.default.defaults.httpsAgent = new https.Agent({ keepAlive: false });
+        axios_1.default.defaults.httpAgent = new http.Agent({ keepAlive: false });
+        const protocol = options.protocol ? options.protocol : 'http';
+        this.options.host = this.options.host.startsWith('http') ? this.options.host : `${protocol}://${this.options.host}`;
+        //combine all parameter for url
+        this.url = `${this.options.host}:${(_a = this.options.port) !== null && _a !== void 0 ? _a : 8080}`;
+        this.axiosInstance = axios_1.default.create({
+            auth: {
+                username: this.options.username || 'glt',
+                password: this.options.password || '',
+            },
+            baseURL: this.url,
+        });
+        // Interceptor for error handling
+        this.axiosInstance.interceptors.response.use((response) => {
+            return response;
+        }, (error) => {
+            this._logger(enums_1.LogLevel.Error, `DachsHttpClient: ${error.message}`, enums_1.LogDebugType.DachsUnreach);
+        });
+    }
+    /**
+     * Takes every key and add the key to the get parameter list
+     * @param {string[]} keys - Array of request keys
+     * @private
+     * @author Trickfilm400
+     * @version 1
+     * @return {string} The final and complete get parameter string
+     */
+    urlBuilder(keys) {
+        let url = '?';
+        keys.forEach((key) => {
+            url += `k=${key}&`;
+        });
+        return url;
+    }
+    /**
+     * main request function
+     * @author Trickfilm400
+     * @version 1
+     * @param {string[]} keys - Array of request keys
+     * @return Promise
+     */
+    fetchByKeys(...keys) {
+        return new Promise((resolve, reject) => {
+            this.axiosInstance
+                .get('/getKey' + this.urlBuilder(keys))
+                .then((res) => {
+                if (!res.data)
+                    reject('No data received');
+                resolve(this.parser(res.data));
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+    }
+    fetchAllKeys() {
+        const all = [
+            ...keyTemplates_1.default.BetriebsDatenDachs,
+            ...keyTemplates_1.default.Aktoren,
+            ...keyTemplates_1.default.BetriebsDaten3112,
+            ...keyTemplates_1.default.Temperatures,
+            ...keyTemplates_1.default.Daten2Waermeerzeuger,
+            ...keyTemplates_1.default.HydraulikSchema,
+            ...keyTemplates_1.default.MehrmodulTechnik,
+            ...keyTemplates_1.default.Tageslauf,
+            ...keyTemplates_1.default.Wartung,
+        ];
+        return this.fetchByKeys(...all);
+    }
+    setKeys(data) {
+        return new Promise((resolve, reject) => {
+            this.axiosInstance
+                .post('/setKeys', Object.entries(data)
+                .map(([key, value]) => `${key}=${value}`)
+                .join('&'))
+                .then((res) => {
+                resolve(res);
+            })
+                .catch(reject);
+        });
+    }
+    /**
+     * Parses the RAW HTTP Response from the request into key-value paris
+     * @author Trickfilm400
+     * @version 1
+     * @param {string} res - The raw Result from the HTTP Request
+     * @return Partial<IReadKeyList> The parsed key value pairs from the result in a JSON
+     * @private
+     */
+    parser(res) {
+        //console.log(res);
+        //remove "\n\n" from the end
+        res = res.trim();
+        //split to line by line
+        const array = res.split('\n');
+        const result = {};
+        //loop through every result line
+        array.forEach((line) => {
+            var _a, _b, _c, _d;
+            //split key and value
+            const [key, value] = line.split('=');
+            //fetch key data, mostly for unit conversion
+            let keyData = _.get(ReadKeyList_1.default, key);
+            let resultValue = (_a = keyData === null || keyData === void 0 ? void 0 : keyData.unit(value)) !== null && _a !== void 0 ? _a : value;
+            if ((_b = this.options.resultConfig) === null || _b === void 0 ? void 0 : _b.flatten) {
+                result[key] = resultValue;
+                return;
+            }
+            //create object value
+            let val = {
+                value: resultValue,
+            };
+            //check for adding optional value data via config
+            if ((_c = this.options.resultConfig) === null || _c === void 0 ? void 0 : _c.addRawValue)
+                val.rawValue = value;
+            if ((_d = this.options.resultConfig) === null || _d === void 0 ? void 0 : _d.addKeyObject)
+                val.key = keyData;
+            //save to return object
+            result[key] = val;
+        });
+        //console.log(result);
+        return result;
+    }
+}
+exports.DachsHttpClient = DachsHttpClient;

package/lib/devices/dachs/lib/dachsInfluxClient.d.ts

@@ -0,0 +1,14 @@
+import { InfluxDbConnectionOptions } from '../../../interfaces';
+/**
+ * This class is highly inspired by https://github.com/victronenergy/venus-docker-grafana-images
+ * Thanks guys, keep up the good work!
+ */
+export declare class DachsInfluxClient {
+    private readonly opts;
+    private client;
+    private accumulatedPoints;
+    constructor(opts: InfluxDbConnectionOptions);
+    private setRetention;
+    addMeasurementToQueue(measurement: string, data: string | number): void;
+    flush(): void;
+}

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

@@ -0,0 +1,18 @@
+import { DeviceClusterType } from '../enums';
+import { iBaseDevice, iDeviceCluster, iDeviceList, iIoBrokerBaseDevice } from '../interfaces';
+export declare class DeviceCluster implements iDeviceCluster {
+    deviceMap: Map<DeviceClusterType, iDeviceList>;
+    constructor(deviceMap?: Map<DeviceClusterType, iDeviceList>);
+    getIoBrokerDevicesByType(type: DeviceClusterType): iIoBrokerBaseDevice[];
+    getDevicesByType(type: DeviceClusterType): Array<iBaseDevice>;
+    addByDeviceType(device?: iBaseDevice): void;
+    addToList(type: DeviceClusterType, device: iBaseDevice): void;
+    toJSON(): Partial<DeviceCluster & {
+        /**
+         * Dictionary representation of the normal device map
+         */
+        deviceDict?: {
+            [p: string]: iDeviceList;
+        };
+    }>;
+}

package/lib/devices/device-cluster.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceCluster = void 0;
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+const device_list_1 = require("./device-list");
+class DeviceCluster {
+    constructor(deviceMap = new Map()) {
+        this.deviceMap = deviceMap;
+    }
+    getIoBrokerDevicesByType(type) {
+        if (type === enums_1.DeviceClusterType.Speaker) {
+            throw new Error('This is no IoBroker Device');
+        }
+        return this.getDevicesByType(type);
+    }
+    getDevicesByType(type) {
+        var _a, _b;
+        return (_b = (_a = this.deviceMap.get(type)) === null || _a === void 0 ? void 0 : _a.getDevices()) !== null && _b !== void 0 ? _b : [];
+    }
+    addByDeviceType(device) {
+        if (!device) {
+            return;
+        }
+        const type = device.deviceType;
+        const clusterTypes = [enums_1.DeviceClusterType.all];
+        switch (type) {
+            case enums_1.DeviceType.Daikin:
+                clusterTypes.push(enums_1.DeviceClusterType.Ac);
+                break;
+            case enums_1.DeviceType.Sonos:
+                clusterTypes.push(enums_1.DeviceClusterType.Speaker);
+                break;
+            case enums_1.DeviceType.Camera:
+                clusterTypes.push(enums_1.DeviceClusterType.Camera);
+                clusterTypes.push(enums_1.DeviceClusterType.MotionDetection);
+                break;
+            case enums_1.DeviceType.HmIpLampe:
+            case enums_1.DeviceType.ZigbeeIlluDimmer:
+            case enums_1.DeviceType.ZigbeeOsramDimmer:
+            case enums_1.DeviceType.ZigbeeIlluLampe:
+            case enums_1.DeviceType.ZigbeeUbisysLampe:
+                clusterTypes.push(enums_1.DeviceClusterType.Lamps);
+                break;
+            case enums_1.DeviceType.HmIpWippe:
+            case enums_1.DeviceType.HmIpTaster:
+            case enums_1.DeviceType.ZigbeeIkeaFernbedienung:
+                clusterTypes.push(enums_1.DeviceClusterType.Buttons);
+                break;
+            case enums_1.DeviceType.HmIpRoll:
+            case enums_1.DeviceType.ZigbeeIlluShutter:
+            case enums_1.DeviceType.ZigbeeUbisysShutter:
+            case enums_1.DeviceType.VeluxShutter:
+                clusterTypes.push(enums_1.DeviceClusterType.Shutter);
+                break;
+            case enums_1.DeviceType.ZigbeeSonoffTemp:
+            case enums_1.DeviceType.SmartGardenSensor:
+                clusterTypes.push(enums_1.DeviceClusterType.TemperaturSensor);
+                clusterTypes.push(enums_1.DeviceClusterType.HumiditySensor);
+                break;
+            case enums_1.DeviceType.HmIpGriff:
+                clusterTypes.push(enums_1.DeviceClusterType.Handle);
+                break;
+            case enums_1.DeviceType.ZigbeeSodaHandle:
+                clusterTypes.push(enums_1.DeviceClusterType.Handle);
+                clusterTypes.push(enums_1.DeviceClusterType.TemperaturSensor);
+                clusterTypes.push(enums_1.DeviceClusterType.HumiditySensor);
+                break;
+            case enums_1.DeviceType.HmIpHeizgruppe:
+                clusterTypes.push(enums_1.DeviceClusterType.Heater);
+                clusterTypes.push(enums_1.DeviceClusterType.TemperaturSensor);
+                clusterTypes.push(enums_1.DeviceClusterType.HumiditySensor);
+                break;
+            case enums_1.DeviceType.HmIpTuer:
+            case enums_1.DeviceType.ZigbeeSMaBiTMagnetContact:
+            case enums_1.DeviceType.ZigbeeAqaraMagnetContact:
+                clusterTypes.push(enums_1.DeviceClusterType.MagnetContact);
+                break;
+            case enums_1.DeviceType.HmIpBewegung:
+            case enums_1.DeviceType.ZigbeeAquaraMotion:
+            case enums_1.DeviceType.ZigbeeSonoffMotion:
+            case enums_1.DeviceType.ZigbeeTuyaMotion:
+            case enums_1.DeviceType.HmIpPraezenz:
+                clusterTypes.push(enums_1.DeviceClusterType.MotionDetection);
+                break;
+            case enums_1.DeviceType.ZigbeeIkeaSteckdose:
+            case enums_1.DeviceType.ZigbeeBlitzShp:
+                clusterTypes.push(enums_1.DeviceClusterType.Outlets);
+                break;
+            case enums_1.DeviceType.ZigbeeIlluLedRGBCCT:
+            case enums_1.DeviceType.ZigbeeLinkindLedRgbCct:
+            case enums_1.DeviceType.ZigbeeInnr142C:
+            case enums_1.DeviceType.GoveeLed:
+                clusterTypes.push(enums_1.DeviceClusterType.LED);
+                break;
+            case enums_1.DeviceType.ZigbeeAquaraVibra:
+                clusterTypes.push(enums_1.DeviceClusterType.Vibration);
+                break;
+            case enums_1.DeviceType.ZigbeeHeimanSmoke:
+                clusterTypes.push(enums_1.DeviceClusterType.SmokeDetector);
+                break;
+            case enums_1.DeviceType.ZigbeeAquaraWater:
+                clusterTypes.push(enums_1.DeviceClusterType.WaterDetectors);
+                break;
+            case enums_1.DeviceType.WledDevice:
+                clusterTypes.push(enums_1.DeviceClusterType.WLED);
+                break;
+            case enums_1.DeviceType.ZigbeeIlluActuator: // Dependent on use case
+            case enums_1.DeviceType.ZigbeeUbisysActuator: // Dependent on use case
+            case enums_1.DeviceType.HmIpTherm: // Humidity and temperature not yet implemented
+            case enums_1.DeviceType.HmIpHeizung: // Setting/Controlling via HM-Ip Heizgruppe
+            case enums_1.DeviceType.unknown:
+            case enums_1.DeviceType.HmIpAccessPoint: // You can't really do stuff with it.
+            case enums_1.DeviceType.ShellyActuator: // Dependent on use case
+                break;
+        }
+        for (const type of clusterTypes) {
+            this.addToList(type, device);
+        }
+    }
+    addToList(type, device) {
+        var _a;
+        const list = (_a = this.deviceMap.get(type)) === null || _a === void 0 ? void 0 : _a.ids;
+        if (list !== undefined) {
+            if (list.indexOf(device.id) < 0) {
+                list.push(device.id);
+            }
+        }
+        else {
+            this.deviceMap.set(type, new device_list_1.DeviceList([device.id]));
+        }
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this);
+    }
+}
+exports.DeviceCluster = DeviceCluster;

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

@@ -0,0 +1,7 @@
+import { iBaseDevice, iDeviceList } from '../interfaces';
+export declare class DeviceList implements iDeviceList {
+    private _ids;
+    constructor(_ids?: string[]);
+    get ids(): string[];
+    getDevices(): Array<iBaseDevice>;
+}

package/lib/devices/device-list.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceList = void 0;
+const api_1 = require("../api");
+class DeviceList {
+    constructor(_ids = []) {
+        this._ids = _ids;
+        // Empty
+    }
+    get ids() {
+        return this._ids;
+    }
+    getDevices() {
+        const result = [];
+        for (const dID of this._ids) {
+            const d = api_1.API.getDevice(dID);
+            if (d !== undefined) {
+                result.push(d);
+            }
+        }
+        return result;
+    }
+}
+exports.DeviceList = DeviceList;

package/lib/devices/deviceUpdater.d.ts

@@ -0,0 +1,6 @@
+import { IDeviceUpdater } from '../interfaces';
+export declare class DeviceUpdater implements IDeviceUpdater {
+    onConnChanged(): void;
+    updateObject(pId: string, pObj: ioBroker.Object): void;
+    updateState(id: string, state: ioBroker.State, initial?: boolean): void;
+}

package/lib/devices/deviceUpdater.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceUpdater = void 0;
+const services_1 = require("../services");
+const IoBrokerDeviceInfo_1 = require("./IoBrokerDeviceInfo");
+const devices_1 = require("./devices");
+const mqtt_1 = require("./mqtt");
+const api_1 = require("../api");
+const logging_1 = require("../logging");
+const enums_1 = require("../enums");
+class DeviceUpdater {
+    onConnChanged() {
+        services_1.TimeCallbackService.performCheck();
+        services_1.TimeCallbackService.performCheck();
+    }
+    updateObject(pId, pObj) {
+        const idSplit = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.idSplitter(pId);
+        if (idSplit.length < 2)
+            return;
+        if (idSplit[0] === devices_1.Devices.IDENTIFIER_HOMEMATIC) {
+            console.log(`Neuer Wert in HomematicIP für ${pId}: ${JSON.stringify(pObj)}`);
+        }
+    }
+    updateState(id, state, initial = false) {
+        var _a;
+        if (state === null) {
+            // Ignore null states
+            return;
+        }
+        if (state.q === 0x20) {
+            // Ignore substitute default values
+            return;
+        }
+        const idSplit = IoBrokerDeviceInfo_1.IoBrokerDeviceInfo.idSplitter(id);
+        if (idSplit.length < 2)
+            return;
+        let classifier = idSplit[0];
+        let devId = idSplit[2];
+        if (idSplit[0] == 'mqtt') {
+            mqtt_1.MqttCoordinator.update(idSplit, state);
+        }
+        else if (idSplit[0] == devices_1.Devices.IDENTIFIER_ZIGBEE2MQTT) {
+            classifier = devices_1.Devices.IDENTIFIER_ZIGBEE;
+            devId = idSplit[2].substring(2);
+        }
+        else if (idSplit[0] == devices_1.Devices.IDENTIFIER_SMART_GARDEN) {
+            if (idSplit[1] === 'admin' ||
+                idSplit.length < 4 ||
+                idSplit[2].indexOf('LOCATION') !== 0 ||
+                idSplit[3].indexOf('DEVICE') !== 0) {
+                // This is no update for a smartgarden device
+                return;
+            }
+            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('products') !== 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 = api_1.API.getDevice(allDevicesKey, false);
+        if (typeof device === 'undefined' || device.update === undefined) {
+            // classifier == Devices.IDENTIFIER_SMART_GARDEN &&
+            //   ServerLogService.writeLog(
+            //     LogLevel.Warn,
+            //     `deviceUpdater.updateState('${id}', ${JSON.stringify(state)}'): Device ${allDevicesKey} type is "${typeof device}"`,
+            //   );
+            return;
+        }
+        try {
+            device.update(idSplit, state, initial, false);
+        }
+        catch (e) {
+            logging_1.ServerLogService.writeLog(enums_1.LogLevel.Alert, `deviceUpdater.updateState('${id}', '${state}'): Error occured updating Device: ${e} \n ${(_a = e === null || e === void 0 ? void 0 : e.stack) !== null && _a !== void 0 ? _a : ''}`);
+        }
+    }
+}
+exports.DeviceUpdater = DeviceUpdater;

package/lib/devices/devices.d.ts

@@ -0,0 +1,81 @@
+import { iBaseDevice, iConfig, iEnergyManager, iRoomImportEnforcer, iTemperatureCollector } from '../interfaces';
+import { Dachs } from './dachs';
+import { iDeviceConfig } from '../interfaces/iDeviceConfig';
+import { UnifiProtect } from './unifi';
+export declare class Devices {
+    /**
+     * A constant for the identifier of HM-IP Adapter devices
+     */
+    static readonly IDENTIFIER_HOMEMATIC: string;
+    /**
+     * A constant for the identifier of JavaScript Adapter devices
+     */
+    static readonly IDENTIFIER_JS: string;
+    /**
+     * A constant for the identifier of Shelly Adapter devices
+     */
+    static readonly IDENTIFIER_Shelly: string;
+    /**
+     * A constant for the identifier of Tuya Adapter devices
+     */
+    static readonly IDENTIFIER_TUYA: string;
+    /**
+     * A constant for the identifier of Zigbee Adapter devices
+     */
+    static readonly IDENTIFIER_ZIGBEE: string;
+    /**
+     * A constant for the identifier of Zigbee2Mqtt Adapter devices
+     */
+    static readonly IDENTIFIER_ZIGBEE2MQTT: string;
+    /**
+     * A constant for the identifier of WLED Adapter devices
+     */
+    static readonly IDENTIFIER_WLED: string;
+    /**
+     * 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
+     */
+    static alLDevices: {
+        [id: string]: iBaseDevice;
+    };
+    /**
+     * A reference to globally active energy manager
+     * @default undefined (no Energy-Manager)
+     */
+    static energymanager?: iEnergyManager;
+    /**
+     * A reference to the Dachs device
+     * @default undefined (no Dachs CHP)
+     */
+    static dachs?: Dachs;
+    /**
+     * A reference to the temperature sensor measuring the warm water temperature
+     * @default undefined (no warm water temperature sensor)
+     */
+    static temperatureWarmWater?: iTemperatureCollector;
+    /**
+     * A reference to the Unifi Protect device
+     */
+    static unifiProtect?: UnifiProtect;
+    constructor(pDeviceData: {
+        [id: string]: iDeviceConfig;
+    }, pRoomImportEnforcer?: iRoomImportEnforcer, config?: iConfig);
+    static midnightReset(): void;
+    static resetDetectionsToday(): void;
+    static getBatteryInfo(): string;
+    private static processShellyDevice;
+    private static processTuyaDevice;
+    private static processZigbeeDevice;
+    private static processVeluxDevice;
+    private static processSmartGardenDevice;
+    private static processWledDevice;
+    private static processHMIPDevice;
+    private static createEnergyManager;
+}