hoffmation-base 0.1.14 → 0.1.18

package/lib/models/rooms/iRoomImportEnforcer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/models/rooms/index.d.ts

@@ -0,0 +1,3 @@
+export * from './RoomBase';
+export * from './iRoomImportEnforcer';
+export * from './RoomSettings/index';

package/lib/models/rooms/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./RoomBase"), exports);
+__exportStar(require("./iRoomImportEnforcer"), exports);
+__exportStar(require("./RoomSettings/index"), exports);

package/lib/models/temperaturSettings.d.ts

@@ -0,0 +1,9 @@
+import { Daytime } from './daytime';
+export declare class TemperaturSettings {
+    start: Daytime;
+    end: Daytime;
+    temperatur: number;
+    active: boolean;
+    constructor(start: Daytime, end: Daytime, temperatur: number, active?: boolean);
+    isNowInRange(): boolean;
+}

package/lib/models/temperaturSettings.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemperaturSettings = void 0;
+class TemperaturSettings {
+    constructor(start, end, temperatur, active = true) {
+        this.start = start;
+        this.end = end;
+        this.temperatur = temperatur;
+        this.active = active;
+    }
+    isNowInRange() {
+        const now = new Date().getTime();
+        const todayStart = new Date().setHours(this.start.hour, this.start.minute);
+        if (now < todayStart) {
+            return false;
+        }
+        const todayEnd = new Date().setHours(this.end.hour, this.end.minute);
+        return now < todayEnd;
+    }
+}
+exports.TemperaturSettings = TemperaturSettings;

package/lib/models/timeCallback.d.ts

@@ -0,0 +1,19 @@
+import { SunTimeOffsets } from '../server/services/time-callback-service';
+export declare class TimeCallback {
+    name: string;
+    type: TimeCallbackType;
+    cFunction: () => void;
+    minuteOffset: number;
+    hours?: number | undefined;
+    minutes?: number | undefined;
+    sunTimeOffset?: SunTimeOffsets | undefined;
+    lastDone: Date;
+    nextToDo?: Date;
+    constructor(name: string, type: TimeCallbackType, cFunction: () => void, minuteOffset: number, hours?: number | undefined, minutes?: number | undefined, sunTimeOffset?: SunTimeOffsets | undefined);
+    recalcNextToDo(now: Date): void;
+}
+export declare enum TimeCallbackType {
+    TimeOfDay = 1,
+    Sunrise = 2,
+    SunSet = 3
+}

package/lib/models/timeCallback.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeCallbackType = exports.TimeCallback = void 0;
+const logLevel_1 = require("./logLevel");
+const log_service_1 = require("../server/services/log-service");
+const time_callback_service_1 = require("../server/services/time-callback-service");
+class TimeCallback {
+    constructor(name, type, cFunction, minuteOffset, hours, minutes, sunTimeOffset) {
+        this.name = name;
+        this.type = type;
+        this.cFunction = cFunction;
+        this.minuteOffset = minuteOffset;
+        this.hours = hours;
+        this.minutes = minutes;
+        this.sunTimeOffset = sunTimeOffset;
+        this.lastDone = new Date(0);
+    }
+    recalcNextToDo(now) {
+        const today = new Date(now.getTime());
+        today.setHours(0, 0, 0, 0);
+        switch (this.type) {
+            case TimeCallbackType.TimeOfDay:
+                if (this.hours === undefined) {
+                    this.hours = 0;
+                }
+                if (this.minutes === undefined) {
+                    this.minutes = 0;
+                }
+                this.nextToDo = new Date(today.getTime() + this.hours * 60 * 60 * 1000 + (this.minutes + this.minuteOffset) * 60 * 1000);
+                if (this.nextToDo < now) {
+                    // Heute ist schon abgelaufen, also morgen festlegen
+                    this.nextToDo = new Date(this.nextToDo.getTime() + 24 * 60 * 60 * 1000);
+                }
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Nächste Zeitevent für "${this.name}" um ${this.nextToDo.toLocaleTimeString('de-DE')}`);
+                break;
+            case TimeCallbackType.Sunrise:
+                let fixedSRDate = new Date(time_callback_service_1.TimeCallbackService.nextSunRise.getTime() + this.minuteOffset * 60 * 1000);
+                if (this.sunTimeOffset) {
+                    const nextMinSR = this.sunTimeOffset.getNextMinimumSunrise();
+                    if (nextMinSR > fixedSRDate && fixedSRDate.getDate() === nextMinSR.getDate()) {
+                        fixedSRDate = nextMinSR;
+                    }
+                }
+                if (now > fixedSRDate) {
+                    return;
+                }
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Nächste Zeitevent für "${this.name}" um ${fixedSRDate.toLocaleTimeString('de-DE')}`);
+                this.nextToDo = fixedSRDate;
+                break;
+            case TimeCallbackType.SunSet:
+                let fixedSSDate = new Date(time_callback_service_1.TimeCallbackService.nextSunSet.getTime() + this.minuteOffset * 60 * 1000);
+                if (this.sunTimeOffset) {
+                    const nextMaxSS = this.sunTimeOffset.getNextMaximumSunset();
+                    if (nextMaxSS < fixedSSDate && fixedSSDate.getDate() === nextMaxSS.getDate()) {
+                        fixedSSDate = nextMaxSS;
+                    }
+                }
+                if (now > fixedSSDate) {
+                    return;
+                }
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Nächste Zeitevent für "${this.name}" um ${fixedSSDate.toLocaleTimeString('de-DE')}`);
+                this.nextToDo = fixedSSDate;
+                break;
+        }
+    }
+}
+exports.TimeCallback = TimeCallback;
+var TimeCallbackType;
+(function (TimeCallbackType) {
+    TimeCallbackType[TimeCallbackType["TimeOfDay"] = 1] = "TimeOfDay";
+    TimeCallbackType[TimeCallbackType["Sunrise"] = 2] = "Sunrise";
+    TimeCallbackType[TimeCallbackType["SunSet"] = 3] = "SunSet";
+})(TimeCallbackType = exports.TimeCallbackType || (exports.TimeCallbackType = {}));

package/lib/server/config/iConfig.d.ts

@@ -0,0 +1,45 @@
+import { LogLevel } from '../../models/logLevel';
+import { iRoomDefaultSettings } from '../../models/rooms/RoomSettings/iRoomDefaultSettings';
+export interface iConfig {
+    roomDefault: iRoomDefaultSettings;
+    timeSettings: iTimeSettings;
+    ioBrokerUrl: string;
+    telegram?: iTelegramSettings;
+    polly?: iPollySettings;
+    mp3Server?: iMp3Settings;
+    weather?: iWeatherSettings;
+    muell?: iMuellSettings;
+}
+export interface iTimePair {
+    hours: number;
+    minutes: number;
+}
+export interface iTimeSettings {
+    nightStart: iTimePair;
+    nightEnd: iTimePair;
+}
+export interface iTelegramSettings {
+    logLevel: LogLevel;
+    telegramToken: string;
+    allowedIDs: number[];
+    subscribedIDs: number[];
+}
+export interface iPollySettings {
+    mp3Path: string;
+    region: string;
+    signatureVersion: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    voiceID: string;
+}
+export interface iMp3Settings {
+    path: string;
+}
+export interface iWeatherSettings {
+    lattitude: string;
+    longitude: string;
+    appid: string;
+}
+export interface iMuellSettings {
+    calendarURL: string;
+}

package/lib/server/config/iConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1 @@
+export * from './iConfig';

package/lib/server/config/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./iConfig"), exports);

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

@@ -0,0 +1,17 @@
+import { deviceConfig } from '../../models/deviceConfig';
+export declare class DeviceInfo {
+    devID: string;
+    room: string;
+    deviceType: string;
+    deviceRoomIndex: number;
+    type: 'device' | 'channel' | 'state';
+    fullName: string;
+    private _customName?;
+    fullID: string;
+    channel?: number;
+    valueName?: string;
+    devConf: deviceConfig;
+    constructor(pDevConf: deviceConfig);
+    set customName(val: string);
+    get customName(): string;
+}

package/lib/server/devices/DeviceInfo.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceInfo = void 0;
+class DeviceInfo {
+    constructor(pDevConf) {
+        this.devConf = pDevConf;
+        this.type = pDevConf.type;
+        this.fullID = pDevConf._id;
+        /**
+         * 0: hm-rpc
+         * 1: rcpInstance
+         * 2: Device ID
+         * 3?: Channel
+         * 4?: ValueName
+         */
+        const idSplit = pDevConf._id.split('.');
+        this.devID = idSplit[2];
+        if (idSplit.length > 3) {
+            this.channel = Number(idSplit[3]);
+        }
+        if (idSplit.length > 4) {
+            this.valueName = idSplit[4];
+        }
+        this.fullName = pDevConf.common.name;
+        /**
+         * 0: Indikator own "00"
+         * 1: "HmIP"
+         * 2: Raum
+         * 3: Was für ein Gerät
+         * 4: Index dieses Gerätes im Raum (ggf. + :Channel)
+         * 5?: Name des Wertes
+         */
+        const nameSplit = pDevConf.common.name.split('-');
+        this.room = nameSplit[2];
+        this.deviceType = nameSplit[3];
+        this.deviceRoomIndex = Number(nameSplit[4].split(':')[0]);
+    }
+    set customName(val) {
+        this._customName = val;
+    }
+    get customName() {
+        if (this._customName !== undefined) {
+            return this._customName;
+        }
+        return this.fullName;
+    }
+}
+exports.DeviceInfo = DeviceInfo;

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

@@ -0,0 +1,5 @@
+import { HmIpGriff } from './hmIPDevices/hmIpGriff';
+export declare class Griffe {
+    static getGriffPosition(): string;
+    static getAllGriffe(): HmIpGriff[];
+}

package/lib/server/devices/Griffe.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Griffe = void 0;
+const devices_1 = require("./devices");
+const FensterPosition_1 = require("./hmIPDevices/FensterPosition");
+const hmIpDeviceType_1 = require("./hmIPDevices/hmIpDeviceType");
+class Griffe {
+    static getGriffPosition() {
+        const griffe = Griffe.getAllGriffe();
+        griffe.sort((a, b) => {
+            a.position;
+            return b.position - a.position;
+        });
+        const response = [`Dies sind die aktuellen Stellungen der FensterGriffe:`];
+        for (const g of griffe) {
+            response.push(`${FensterPosition_1.FensterPosition[g.position]} Fenster: "${g.info.customName}"`);
+        }
+        return response.join('\n');
+    }
+    static getAllGriffe() {
+        const griffe = [];
+        for (const dID in devices_1.Devices.hmIP) {
+            const d = devices_1.Devices.hmIP[dID];
+            if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpGriff) {
+                griffe.push(d);
+            }
+        }
+        return griffe;
+    }
+}
+exports.Griffe = Griffe;

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

@@ -0,0 +1,8 @@
+import { HmIpHeizgruppe } from './hmIPDevices/hmIpHeizgruppe';
+export declare class Heizgruppen {
+    static getInfo(): string;
+    static getSpecificInfo(pText: string | undefined): Promise<string>;
+    static getProblems(): string;
+    static getAllGruppen(): HmIpHeizgruppe[];
+    static getSpecificGroup(name: string): HmIpHeizgruppe | undefined;
+}

package/lib/server/devices/Heizgruppen.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heizgruppen = void 0;
+const persist_1 = require("../services/dbo/persist");
+const devices_1 = require("./devices");
+const hmIpDeviceType_1 = require("./hmIPDevices/hmIpDeviceType");
+class Heizgruppen {
+    static getInfo() {
+        const gruppen = Heizgruppen.getAllGruppen();
+        gruppen.sort((a, b) => {
+            return a.info.customName.localeCompare(b.info.customName);
+        });
+        const response = [`Dies sind die aktuellen Informationen der Heizungen:`];
+        response.push(`Name\t\tLuft Feuchtigkeit\t\tAktuelle Temperatur\t\tSoll Temperatur\t\tVentilstellung`);
+        for (const g of gruppen) {
+            response.push(`${g.info.customName}:\t\t${g.humidity}%\t\t${g.sTemperatur}\t\t${g.desiredTemperatur}°C\t\t${g.sLevel}`);
+        }
+        return response.join('\n');
+    }
+    static async getSpecificInfo(pText) {
+        if (pText === undefined || !pText.includes('"')) {
+            return `Bitte übergeben Sie eine Heizgruppe innerhalb von "". z.B. "EG Flur HeizGr"`;
+        }
+        const searchText = pText.split('"')[1];
+        const group = this.getSpecificGroup(searchText);
+        if (group === undefined) {
+            return `"${searchText}" ist keine gültige Heizgruppe, im Folgenden ist eine Liste aller gültigen Heizgruppen:\n${this.getInfo()}`;
+        }
+        const results = await persist_1.Persist.readTemperaturDataPoint(group, 20);
+        const response = [`Dies sind die letzten 20 Messpunkte der Heizgruppe:`];
+        response.push(`Zeitpunkt\t\tIst-Temperatur\t\tSoll-Temperatur\t\tVentilstellung`);
+        for (const r of results) {
+            response.push(`${r.date.toLocaleTimeString('de-DE')}:\t\t${r.istTemperatur}°C\t\t${r.sollTemperatur}°C\t\t${r.level}%`);
+        }
+        return response.join('\n');
+    }
+    static getProblems() {
+        const groups = this.getAllGruppen();
+        const response = [`Dies sind die bestehenden Differenzen:`];
+        response.push(`Raumname\t\tIst-Temperatur\t\tGerät`);
+        for (const g of groups) {
+            const heizungen = g.getBelongingHeizungen();
+            const tempProblem = [`${g.info.room}\t\t${g.iTemperatur}°C\t\t${g.info.customName}`];
+            let print = false;
+            for (const h of heizungen) {
+                if (h.iTemperatur !== g.iTemperatur) {
+                    print = true;
+                }
+                tempProblem.push(`${h.info.room}\t\t${h.iTemperatur}°C\t\t${h.info.customName}`);
+            }
+            if (print) {
+                response.push(tempProblem.join('\n'));
+                response.push(' ');
+            }
+        }
+        return response.join('\n');
+    }
+    static getAllGruppen() {
+        const gruppen = [];
+        for (const dID in devices_1.Devices.hmIP) {
+            const d = devices_1.Devices.hmIP[dID];
+            if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpHeizgruppe) {
+                gruppen.push(d);
+            }
+        }
+        return gruppen;
+    }
+    static getSpecificGroup(name) {
+        for (const dID in devices_1.Devices.hmIP) {
+            const d = devices_1.Devices.hmIP[dID];
+            if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpHeizgruppe && d.info.customName === name) {
+                return d;
+            }
+        }
+        return undefined;
+    }
+}
+exports.Heizgruppen = Heizgruppen;

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

@@ -0,0 +1,5 @@
+import { HmIpRoll } from './hmIPDevices/hmIpRoll';
+export declare class Rolladen {
+    static getRolladenPosition(): string;
+    static getAllRollos(): HmIpRoll[];
+}

package/lib/server/devices/Rollos.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rolladen = void 0;
+const devices_1 = require("./devices");
+const hmIpDeviceType_1 = require("./hmIPDevices/hmIpDeviceType");
+const RoomBase_1 = require("../../models/rooms/RoomBase");
+class Rolladen {
+    static getRolladenPosition() {
+        var _a, _b, _c, _d;
+        const rollos = Rolladen.getAllRollos();
+        rollos.sort((a, b) => {
+            return b.currentLevel - a.currentLevel;
+        });
+        const response = [`Dies sind die aktuellen Rollo Positionen:`];
+        for (const r of rollos) {
+            response.push(`${r.currentLevel}% Rollo: "${r.info.customName}" Gewünschte Position: ${r.desiredFensterLevel}`);
+        }
+        response.push(`\nDie nächsten Zeiten zum Hochfahren:`);
+        const down = [`\nDie nächsten Zeiten zum Runterfahren:`];
+        const rooms = RoomBase_1.RoomBase.allRooms;
+        for (const r of rooms) {
+            for (const f of r.FensterGroup.fenster) {
+                if (f.rollo) {
+                    response.push(`Rollo: "${f.rollo.info.customName}"\t${f.noRolloOnSunrise ? 'Hochfahren inaktiv' : (_b = (_a = r.sonnenAufgangCallback) === null || _a === void 0 ? void 0 : _a.nextToDo) === null || _b === void 0 ? void 0 : _b.toLocaleTimeString()}`);
+                    down.push(`Rollo: "${f.rollo.info.customName}"\t${(_d = (_c = r.sonnenUntergangCallback) === null || _c === void 0 ? void 0 : _c.nextToDo) === null || _d === void 0 ? void 0 : _d.toLocaleTimeString()}`);
+                }
+            }
+        }
+        response.push(down.join('\n'));
+        return response.join('\n');
+    }
+    static getAllRollos() {
+        const rollos = [];
+        for (const dID in devices_1.Devices.hmIP) {
+            const d = devices_1.Devices.hmIP[dID];
+            if (d.deviceType === hmIpDeviceType_1.HmIpDeviceType.HmIpRoll) {
+                rollos.push(d);
+            }
+        }
+        return rollos;
+    }
+}
+exports.Rolladen = Rolladen;

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

@@ -0,0 +1,13 @@
+/// <reference types="iobroker" />
+import { Devices } from './devices';
+import { IDeviceUpdater } from './iDeviceUpdater';
+export declare class DeviceUpdater implements IDeviceUpdater {
+    private static IDENTIFIER_HOMEMATIC;
+    private static IDENTIFIER_ZIGBEE;
+    devices: Devices;
+    constructor(pDevices: Devices);
+    updateObject(pId: string, pObj: ioBroker.Object): void;
+    updateState(id: string, state: ioBroker.State, initial?: boolean): void;
+    private updateHomeMaticDevice;
+    private updateZigbeeDevice;
+}

package/lib/server/devices/deviceUpdater.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceUpdater = void 0;
+const logLevel_1 = require("../../models/logLevel");
+const log_service_1 = require("../services/log-service");
+const devices_1 = require("./devices");
+class DeviceUpdater {
+    constructor(pDevices) {
+        this.devices = pDevices;
+    }
+    updateObject(pId, pObj) {
+        const idSplit = pId.split('.');
+        if (idSplit.length < 2)
+            return;
+        if (idSplit[0] === DeviceUpdater.IDENTIFIER_HOMEMATIC) {
+            console.log(`Neuer Wert in HomematicIP für ${pId}: ${JSON.stringify(pObj)}`);
+        }
+    }
+    updateState(id, state, initial = false) {
+        if (state === null) {
+            // Ignore null states
+            return;
+        }
+        const idSplit = id.split('.');
+        if (idSplit.length < 2)
+            return;
+        if (idSplit[0] === DeviceUpdater.IDENTIFIER_HOMEMATIC) {
+            try {
+                this.updateHomeMaticDevice(idSplit, state, initial);
+            }
+            catch (e) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `deviceUpdater.updateState('${id}', '${state}'): Error occured updating Device: ${e} \n ${e.stack}`);
+            }
+        }
+        else if (idSplit[0] === DeviceUpdater.IDENTIFIER_ZIGBEE) {
+            try {
+                this.updateZigbeeDevice(idSplit, state, initial);
+            }
+            catch (e) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Alert, `deviceUpdater.updateState('${id}', '${state}'): Error occured updating Device: ${e} \n ${e.stack}`);
+            }
+        }
+        else {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `unbekannter Identifier: "${idSplit[0]}"`);
+        }
+    }
+    updateHomeMaticDevice(idSplit, state, initial = false) {
+        const device = devices_1.Devices.hmIP[idSplit[2]];
+        if (typeof device === 'undefined') {
+            return;
+        }
+        device.update(idSplit, state, initial);
+    }
+    updateZigbeeDevice(idSplit, state, initial = false) {
+        const device = devices_1.Devices.Zigbee[idSplit[2]];
+        if (typeof device === 'undefined') {
+            return;
+        }
+        device.update(idSplit, state, initial);
+    }
+}
+exports.DeviceUpdater = DeviceUpdater;
+DeviceUpdater.IDENTIFIER_HOMEMATIC = 'hm-rpc';
+DeviceUpdater.IDENTIFIER_ZIGBEE = 'zigbee';

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

@@ -0,0 +1,21 @@
+import { IOBrokerConnection } from '../ioBroker/connection';
+import { HmIPDevice } from './hmIPDevices/hmIpDevice';
+import { ZigbeeDevice } from './zigbee/zigbeeDevice';
+import { deviceConfig } from '../../models/deviceConfig';
+import { iRoomImportEnforcer } from '../../models/rooms/iRoomImportEnforcer';
+export declare class Devices {
+    static hmIP: {
+        [id: string]: HmIPDevice;
+    };
+    static Zigbee: {
+        [id: string]: ZigbeeDevice;
+    };
+    constructor(pDeviceData: {
+        [id: string]: deviceConfig;
+    }, pRoomImportEnforcer: iRoomImportEnforcer);
+    static addIoConnection(pIoConnection: IOBrokerConnection): void;
+    static midnightReset(): void;
+    static resetPraesenzCount(): void;
+    private processZigbeeDevice;
+    private processHMIPDevice;
+}