hoffmation-base 0.1.14 → 0.1.18

package/lib/server/devices/zigbee/zigbeeIlluDimmer.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluDimmer = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const dimmerSettings_1 = require("../../../models/dimmerSettings");
+const time_callback_service_1 = require("../../services/time-callback-service");
+const utils_1 = require("../../services/utils/utils");
+class ZigbeeIlluDimmer extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeIlluDimmer);
+        this.lightOn = false;
+        this.queuedValue = null;
+        this.brightness = 0;
+        this.transitionTime = 0;
+        this.settings = new dimmerSettings_1.DimmerSettings();
+        this.stateID = 'state';
+        this.brightnessID = 'brightness';
+        this.transitionID = 'transition_time';
+        this.turnOffTimeout = undefined;
+        this.turnOffTime = 0;
+        this.stateID = `${this.info.fullID}.state`;
+        this.brightnessID = `${this.info.fullID}.brightness`;
+        this.transitionID = `${this.info.fullID}.transition_time`;
+    }
+    update(idSplit, state, initial = false) {
+        this.queuedValue = null;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Dimmer Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'state':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Dimmer Update für ${this.info.customName} auf ${state.val}`);
+                this.lightOn = state.val;
+                break;
+            case 'brightness':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Dimmer Helligkeit Update für ${this.info.customName} auf ${state.val}`);
+                this.brightness = state.val;
+                break;
+            case 'transition_time':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Dimmer Transition Time Update für ${this.info.customName} auf ${state.val}`);
+                this.transitionTime = state.val;
+                break;
+        }
+    }
+    setTimeBased(time, timeout = -1, force = false) {
+        switch (time) {
+            case time_callback_service_1.TimeOfDay.Night:
+                this.setLight(true, timeout, force, 50);
+                break;
+            case time_callback_service_1.TimeOfDay.AfterSunset:
+            case time_callback_service_1.TimeOfDay.BeforeSunrise:
+                this.setLight(true, timeout, force, 75);
+                break;
+            case time_callback_service_1.TimeOfDay.Daylight:
+                this.setLight(true, timeout, force, 100);
+                break;
+        }
+    }
+    setLight(pValue, timeout = -1, force = false, brightness = -1, transitionTime = -1) {
+        if (this.stateID === '') {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine State ID für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (!this.ioConn) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (transitionTime > -1) {
+            this.ioConn.setState(this.transitionID, transitionTime, (err) => {
+                if (err) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Dimmer TransitionTime schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+        if (!force && utils_1.Utils.nowMS() < this.turnOffTime) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Skip automatic command for "${this.info.customName}" to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleTimeString()}`);
+            return;
+        }
+        if (pValue && brightness === -1 && this.brightness < 10) {
+            brightness = 10;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Dimmer Schalten: "${this.info.customName}" An: ${pValue}\tHelligkeit: ${brightness}%`);
+        this.ioConn.setState(this.stateID, pValue, (err) => {
+            if (err) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Dimmer schalten ergab Fehler: ${err}`);
+            }
+        });
+        this.queuedValue = pValue;
+        if (brightness > -1) {
+            this.ioConn.setState(this.brightnessID, brightness, (err) => {
+                if (err) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Dimmer Helligkeit schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+        if (this.turnOffTimeout !== undefined) {
+            clearTimeout(this.turnOffTimeout);
+            this.turnOffTimeout = undefined;
+        }
+        if (timeout < 0 || !pValue) {
+            return;
+        }
+        this.turnOffTime = utils_1.Utils.nowMS() + timeout;
+        this.turnOffTimeout = utils_1.Utils.guardedTimeout(() => {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Delayed Turnoff for "${this.info.customName}" initiated`);
+            this.turnOffTimeout = undefined;
+            if (!this.room) {
+                this.setLight(false, -1, true);
+            }
+            else {
+                this.room.setLightTimeBased(true);
+            }
+        }, timeout, this);
+    }
+    toggleLight(time, force = false) {
+        const newVal = this.queuedValue !== null ? !this.queuedValue : !this.lightOn;
+        const timeout = newVal && force ? 30 * 60 * 1000 : -1;
+        if (newVal && time !== undefined) {
+            this.setTimeBased(time, timeout, force);
+            return true;
+        }
+        this.setLight(newVal, timeout, force);
+        return newVal;
+    }
+}
+exports.ZigbeeIlluDimmer = ZigbeeIlluDimmer;

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

@@ -0,0 +1,10 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeIlluActuator } from './zigbeeIlluActuator';
+export declare class ZigbeeIlluLampe extends ZigbeeIlluActuator {
+    get lightOn(): boolean;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setLight(pValue: boolean, timeout?: number, force?: boolean): void;
+    toggleLight(force?: boolean): boolean;
+}

package/lib/server/devices/zigbee/zigbeeIlluLampe.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluLampe = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const zigbeeIlluActuator_1 = require("./zigbeeIlluActuator");
+class ZigbeeIlluLampe extends zigbeeIlluActuator_1.ZigbeeIlluActuator {
+    get lightOn() {
+        return super.actuatorOn;
+    }
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeIlluLampe);
+    }
+    update(idSplit, state, initial = false) {
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'state':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `Lampen Update für ${this.info.customName} auf ${state.val}`);
+                break;
+        }
+    }
+    setLight(pValue, timeout = -1, force = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Lampenaktor schalten: "${this.info.customName}" Wert: ${pValue}`);
+        super.setActuator(pValue, timeout, force);
+    }
+    toggleLight(force = false) {
+        return super.toggleActuator(force);
+    }
+}
+exports.ZigbeeIlluLampe = ZigbeeIlluLampe;

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

@@ -0,0 +1,22 @@
+/// <reference types="iobroker" />
+import { DeviceInfo } from '../DeviceInfo';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { LedSettings } from '../../../models/ledSettings';
+import { TimeOfDay } from '../../services/time-callback-service';
+export declare class ZigbeeIlluLedRGBCCT extends ZigbeeDevice {
+    static DEFAULT_COLOR_WARM: string;
+    on: boolean;
+    brightness: number;
+    color: string;
+    colortemp: number;
+    settings: LedSettings;
+    private stateID;
+    private brightnessID;
+    private colorID;
+    private colorTempID;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    setTimeBased(time: TimeOfDay): void;
+    setLight(pValue: boolean, brightness?: number, color?: string, colortemp?: number): void;
+    toggleLight(): boolean;
+}

package/lib/server/devices/zigbee/zigbeeIlluLedRGBCCT.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeIlluLedRGBCCT = void 0;
+const logLevel_1 = require("../../../models/logLevel");
+const log_service_1 = require("../../services/log-service");
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const zigbeeDeviceType_1 = require("./zigbeeDeviceType");
+const ledSettings_1 = require("../../../models/ledSettings");
+const time_callback_service_1 = require("../../services/time-callback-service");
+class ZigbeeIlluLedRGBCCT extends zigbeeDevice_1.ZigbeeDevice {
+    // private effectID: string = '';
+    constructor(pInfo) {
+        super(pInfo, zigbeeDeviceType_1.ZigbeeDeviceType.ZigbeeIlluLedRGBCCT);
+        this.on = false;
+        this.brightness = 0;
+        this.color = '#fcba32';
+        this.colortemp = 500;
+        this.settings = new ledSettings_1.LedSettings();
+        this.stateID = 'state';
+        this.brightnessID = 'brightness';
+        this.colorID = '';
+        this.colorTempID = '';
+        this.stateID = `${this.info.fullID}.state`;
+        this.brightnessID = `${this.info.fullID}.brightness`;
+        this.colorID = `${this.info.fullID}.color`;
+        this.colorTempID = `${this.info.fullID}.colortemp`;
+        // this.effectID = `${this.info.fullID}.effect`;
+    }
+    update(idSplit, state, initial = false) {
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `LED Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`);
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'state':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `LED Update für ${this.info.customName} auf ${state.val}`);
+                this.on = state.val;
+                break;
+            case 'brightness':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `LED Helligkeit Update für ${this.info.customName} auf ${state.val}`);
+                this.brightness = state.val;
+                break;
+            case 'color':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `LED Color Update für ${this.info.customName} auf ${state.val}`);
+                this.color = state.val;
+                break;
+            case 'colortemp':
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `LED Color Update für ${this.info.customName} auf ${state.val}`);
+                this.colortemp = state.val;
+                break;
+        }
+    }
+    setTimeBased(time) {
+        switch (time) {
+            case time_callback_service_1.TimeOfDay.Night:
+                if (this.settings.nightOn) {
+                    this.setLight(true, this.settings.nightBrightness, this.settings.nightColor, this.settings.nightColorTemp);
+                }
+                break;
+            case time_callback_service_1.TimeOfDay.AfterSunset:
+                if (this.settings.duskOn) {
+                    this.setLight(true, this.settings.duskBrightness, this.settings.duskColor, this.settings.duskColorTemp);
+                }
+                break;
+            case time_callback_service_1.TimeOfDay.BeforeSunrise:
+                if (this.settings.dawnOn) {
+                    this.setLight(true, this.settings.dawnBrightness, this.settings.dawnColor, this.settings.dawnColorTemp);
+                }
+                break;
+            case time_callback_service_1.TimeOfDay.Daylight:
+                if (this.settings.dayOn) {
+                    this.setLight(true, this.settings.dayBrightness, this.settings.dayColor, this.settings.dayColorTemp);
+                }
+                break;
+        }
+    }
+    setLight(pValue, brightness = -1, color = '', colortemp = -1) {
+        if (this.stateID === '') {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine State ID für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (!this.ioConn) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+            return;
+        }
+        if (pValue && brightness === -1 && this.brightness < 10) {
+            brightness = 10;
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `LED Schalten: "${this.info.customName}" An: ${pValue}\tHelligkeit: ${brightness}%\tFarbe: "${color}"\tColorTemperatur: ${colortemp}`);
+        if (color !== '') {
+            this.ioConn.setState(this.colorID, color, (err) => {
+                if (err) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `LED Farbe schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+        if (colortemp > -1) {
+            this.ioConn.setState(this.colorTempID, colortemp, (err) => {
+                if (err) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `LED Farbwärme schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+        this.ioConn.setState(this.stateID, pValue, (err) => {
+            if (err) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `LED schalten ergab Fehler: ${err}`);
+            }
+        });
+        if (brightness > -1) {
+            this.ioConn.setState(this.brightnessID, brightness, (err) => {
+                if (err) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `LED Helligkeit schalten ergab Fehler: ${err}`);
+                }
+            });
+        }
+    }
+    toggleLight() {
+        const newVal = !this.on;
+        this.setLight(newVal);
+        return newVal;
+    }
+}
+exports.ZigbeeIlluLedRGBCCT = ZigbeeIlluLedRGBCCT;
+ZigbeeIlluLedRGBCCT.DEFAULT_COLOR_WARM = '#f2b200';

package/lib/server/index.d.ts

@@ -0,0 +1,4 @@
+export * from './config/index';
+export * from './devices/index';
+export * from './ioBroker/index';
+export * from './services/index';

package/lib/server/index.js

@@ -0,0 +1,16 @@
+"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("./config/index"), exports);
+__exportStar(require("./devices/index"), exports);
+__exportStar(require("./ioBroker/index"), exports);
+__exportStar(require("./services/index"), exports);

package/lib/server/ioBroker/connection.d.ts

@@ -0,0 +1,160 @@
+/// <reference types="iobroker" />
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { SocketIOConnectOpts } from './socketIOConnectOptions';
+import { ConnectionCallbacks } from '../../models/connectionCallbacks';
+export declare class IOBrokerConnection {
+    private _isExecutedInBrowser;
+    private _authInfo;
+    private _authRunning;
+    private _cmdData;
+    private _cmdQueue?;
+    private _connCallbacks;
+    private _cmdInstance;
+    private _countDown;
+    private _defaultMode;
+    private _disconnectedSince?;
+    private _enums?;
+    private _isAuthDone;
+    private _isAuthRequired;
+    private _isConnected;
+    private _isSecure;
+    private _lastTimer?;
+    private _namespace;
+    private _objects?;
+    private _onConnChange;
+    private _onUpdate;
+    private _reconnectInterval;
+    private _reloadInterval;
+    private _socket;
+    private _type;
+    private _timer?;
+    private _timeout;
+    private _user;
+    private _useStorage;
+    private _connectInterval?;
+    private _countInterval?;
+    private _gettingStates?;
+    /**
+     * Getter isExecutedInBrowser
+     * @return {boolean }
+     */
+    get isExecutedInBrowser(): boolean;
+    /**
+     * Getter enums
+     * @return {unknown}
+     */
+    get enums(): {
+        [groupName: string]: Record<string, ioBroker.Enum>;
+    } | undefined;
+    /**
+     * Getter isAuthDone
+     * @return {boolean }
+     */
+    get isAuthDone(): boolean;
+    /**
+     * Getter namespace
+     * @return {string }
+     */
+    get namespace(): string;
+    /**
+     * Getter objects
+     * @return {unknown}
+     */
+    get objects(): Record<string, ioBroker.Object> | undefined;
+    /**
+     * Getter type
+     * @return {string }
+     */
+    get type(): string;
+    /**
+     * Getter timeout
+     * @return {number }
+     */
+    get timeout(): number;
+    /**
+     * Getter user
+     * @return {unknown}
+     */
+    get user(): string;
+    /**
+     * Setter enums
+     * @param {unknown} value
+     */
+    set enums(value: {
+        [groupName: string]: Record<string, ioBroker.Enum>;
+    } | undefined);
+    /**
+     * Setter namespace
+     * @param {string } value
+     */
+    set namespace(value: string);
+    /**
+     * Setter objects
+     * @param {unknown} value
+     */
+    set objects(value: Record<string, ioBroker.Object> | undefined);
+    /**
+     * Setter type
+     * @param {string } value
+     */
+    set type(value: string);
+    /**
+     * Setter timeout
+     * @param {number } value
+     */
+    set timeout(value: number);
+    /**
+     * Setter user
+     * @param {unknown} value
+     */
+    set user(value: string);
+    constructor(connOptions?: SocketIOConnectOpts, connCallbacks?: ConnectionCallbacks, objectsRequired?: boolean);
+    private _checkConnection;
+    private _monitor;
+    private _onAuth;
+    reconnect(pConnOptions: unknown): void;
+    logout(callback: unknown): void;
+    getVersion(callback: unknown): void;
+    private _checkAuth;
+    readFile(filename: string, callback: ioBroker.ReadFileCallback, isRemote: boolean): void;
+    getMimeType(ext: string): string;
+    readFile64(filename: string, callback: unknown, isRemote: boolean): void;
+    writeFile(filename: string, data: unknown | string, mode: number, callback: ioBroker.ErrnoCallback, ...args: unknown[]): void;
+    writeFile64(filename: string, data: string, callback: ioBroker.ErrnoCallback): void;
+    readDir(dirname: string, callback: ioBroker.ReadDirCallback): void;
+    mkdir(dirname: string, callback: ioBroker.ErrnoCallback): void;
+    unlink(name: string, callback: ioBroker.ErrorCallback): void;
+    renameFile(oldname: string, newname: string, callback: ioBroker.ErrnoCallback): void;
+    setState(pointId: string, state: string | number | boolean | ioBroker.State | ioBroker.SettableState | null, callback?: ioBroker.SetStateCallback): void;
+    sendTo(instance: string, command: string, payload: ioBroker.MessagePayload, callback: ioBroker.MessageCallback | ioBroker.MessageCallbackInfo): void;
+    getStates(IDs: string[] | null, callback: ioBroker.GetStatesCallback): void;
+    private _fillChildren;
+    getObjects(useCache: boolean, callback: ioBroker.GetObjectsCallback): void;
+    getChildren(id: string, useCache: boolean, callback: (err?: Error | null, children?: string[]) => void, ...args: unknown[]): void;
+    getObject(id: string, useCache: boolean, callback: ioBroker.GetObjectCallback): void;
+    getEnums(enumName: string, useCache: boolean, callback: ioBroker.GetEnumsCallback): void;
+    getSyncTime(): Date;
+    addObject(objId: unknown, obj: unknown, callback: unknown): void;
+    delObject(objId: string): void;
+    httpGet(url: string, callback: (res: IncomingMessage | Error) => void): void;
+    logError(errorText: string): void;
+    private _queueCmdIfRequired;
+    authenticate(user: string, password: string, salt: string): void;
+    getConfig(useCache: boolean, callback: (error: Error | null, conf?: Record<string, any>) => void, ...args: unknown[]): void;
+    sendCommand(instance: string, command: string, data: string | number | boolean | unknown[] | Record<string, any> | null, ack?: boolean): void;
+    private _detectViews;
+    readProjects(callback: (err?: NodeJS.ErrnoException | null, objects?: Array<{
+        name: string;
+        readOnly: undefined | boolean;
+        mode: number;
+    }>) => void): void;
+    chmodProject(projectDir: string, mode: number | string, callback: ioBroker.ChownFileCallback): void;
+    clearCache(): void;
+    getHistory(id: string, options: ioBroker.GetHistoryOptions & {
+        timeout?: number;
+    }, callback: ioBroker.GetHistoryCallback, ...args: unknown[]): void;
+    private getLiveHost;
+    private readDirAsZip;
+    private writeDirAsZip;
+}