hoffmation-base 2.19.7 → 2.20.0-beta.1

package/lib/index.js

@@ -19,6 +19,7 @@ const server_1 = require("./server");
 const models_1 = require("./models");
 const dachs_1 = require("./server/devices/dachs");
 require("@iobroker/types");
+const govee_1 = require("./server/services/govee");
 __exportStar(require("./models/index"), exports);
 __exportStar(require("./server/index"), exports);
 __exportStar(require("./liquid-pid"), exports);
@@ -80,6 +81,10 @@ class HoffmationBase {
             server_1.SonosService.addOwnDevices(server_1.OwnSonosDevices.ownDevices);
             server_1.SonosService.initialize();
         }
+        if (server_1.SettingsService.settings.goveeDevicesPresent) {
+            govee_1.GooveeService.addOwnDevices(govee_1.OwnGoveeDevices.ownDevices);
+            govee_1.GooveeService.initialize();
+        }
         if ((_b = server_1.SettingsService.settings.daikin) === null || _b === void 0 ? void 0 : _b.active) {
             server_1.DaikinService.addOwnDevices(server_1.OwnAcDevices.ownDevices);
             server_1.DaikinService.initialize();

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

@@ -30,6 +30,7 @@ export interface iConfig {
     espresense?: iEspresenseSettings;
     ioBrokerUrl: string;
     ioBroker?: iIobrokerSettigns;
+    goveeDevicesPresent?: boolean;
     heaterSettings?: iHeaterSettings;
     logSettings?: iLogSettings;
     mp3Server?: iMp3Settings;

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

@@ -4,7 +4,6 @@ export interface iLedRgbCct extends iDimmableLamp {
     settings: LedSettings;
     readonly color: string;
     readonly colortemp: number;
-    update(idSplit: string[], state: ioBroker.State, initial: boolean): void;
     /**
      * @inheritDoc
      */

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

@@ -81,6 +81,7 @@ class DeviceCluster {
             case deviceType_1.DeviceType.ZigbeeIlluLedRGBCCT:
             case deviceType_1.DeviceType.ZigbeeLinkindLedRgbCct:
             case deviceType_1.DeviceType.ZigbeeInnr142C:
+            case deviceType_1.DeviceType.GoveeLed:
                 clusterTypes.push(device_cluster_type_1.DeviceClusterType.LED);
                 break;
             case deviceType_1.DeviceType.ZigbeeAquaraVibra:

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

@@ -43,6 +43,7 @@ export declare enum DeviceType {
     ShellyTrv = 402,
     TuyaGarageDoorOpener = 501,
     WledDevice = 1001,
+    GoveeLed = 1002,
     Daikin = 2001,
     Sonos = 3001,
     Espresense = 4001,

package/lib/server/devices/deviceType.js

@@ -47,6 +47,7 @@ var DeviceType;
     DeviceType[DeviceType["ShellyTrv"] = 402] = "ShellyTrv";
     DeviceType[DeviceType["TuyaGarageDoorOpener"] = 501] = "TuyaGarageDoorOpener";
     DeviceType[DeviceType["WledDevice"] = 1001] = "WledDevice";
+    DeviceType[DeviceType["GoveeLed"] = 1002] = "GoveeLed";
     DeviceType[DeviceType["Daikin"] = 2001] = "Daikin";
     DeviceType[DeviceType["Sonos"] = 3001] = "Sonos";
     DeviceType[DeviceType["Espresense"] = 4001] = "Espresense";

package/lib/server/services/govee/govee-service.d.ts

@@ -0,0 +1,16 @@
+import { Device as GoveeDevice } from 'theimo1221-govee-lan-control';
+import { OwnGoveeDevice } from './own-govee-device';
+export declare class GooveeService {
+    static all: GoveeDevice[];
+    static devicesDict: {
+        [name: string]: GoveeDevice;
+    };
+    private static goveeApi;
+    private static ownDevices;
+    static addOwnDevices(gvDevice: {
+        [name: string]: OwnGoveeDevice;
+    }): void;
+    static initialize(): void;
+    private static initializeDevice;
+    private static updateDevice;
+}

package/lib/server/services/govee/govee-service.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GooveeService = void 0;
+const log_service_1 = require("../log-service");
+const models_1 = require("../../../models");
+const theimo1221_govee_lan_control_1 = __importDefault(require("theimo1221-govee-lan-control"));
+class GooveeService {
+    static addOwnDevices(gvDevice) {
+        this.ownDevices = gvDevice;
+    }
+    static initialize() {
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Initializing Goovee-Service`);
+        this.all = [];
+        this.goveeApi = new theimo1221_govee_lan_control_1.default();
+        this.goveeApi.on('deviceAdded', (device) => {
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `GoveeDevice ${device.deviceID} joined`);
+            GooveeService.initializeDevice(device);
+        });
+        this.goveeApi.on('updatedStatus', (device, data, _stateChanged) => {
+            GooveeService.updateDevice(device, data);
+        });
+    }
+    static initializeDevice(d) {
+        this.devicesDict[d.deviceID] = d;
+        if (this.ownDevices[d.deviceID] === undefined) {
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Alert, `Unknown Govee Device "${d.deviceID}"`);
+            return;
+        }
+        this.ownDevices[d.deviceID].device = d;
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Govee ${d.deviceID} found at address ${d.ip}`);
+    }
+    static updateDevice(device, data) {
+        if (this.ownDevices[device.deviceID] === undefined) {
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Alert, `Unknown Govee Device "${device.deviceID}"`);
+            return;
+        }
+        this.ownDevices[device.deviceID].update(data);
+    }
+}
+exports.GooveeService = GooveeService;
+GooveeService.all = [];
+GooveeService.devicesDict = {};
+GooveeService.ownDevices = {};

package/lib/server/services/govee/index.d.ts

@@ -0,0 +1,3 @@
+export * from './govee-service';
+export * from './own-govee-device';
+export * from './own-govee-devices';

package/lib/server/services/govee/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./govee-service"), exports);
+__exportStar(require("./own-govee-device"), exports);
+__exportStar(require("./own-govee-devices"), exports);

package/lib/server/services/govee/own-govee-device.d.ts

@@ -0,0 +1,55 @@
+import { DeviceInfo, DeviceType, iTemporaryDisableAutomatic } from '../../devices';
+import { LedSettings, LogLevel, RoomBase, TimeOfDay } from '../../../models';
+import { LogDebugType } from '../log-service';
+import { DeviceCapability } from '../../devices/DeviceCapability';
+import { iLedRgbCct } from '../../devices/baseDeviceInterfaces/iLedRgbCct';
+import { Device as GoveeDevice, DeviceState as GoveeDeviceState } from 'theimo1221-govee-lan-control';
+import { BlockAutomaticHandler } from '../blockAutomaticHandler';
+export declare class OwnGoveeDevice implements iLedRgbCct, iTemporaryDisableAutomatic {
+    device: GoveeDevice | undefined;
+    settings: LedSettings;
+    readonly deviceType: DeviceType;
+    readonly deviceId: string;
+    readonly deviceCapabilities: DeviceCapability[];
+    readonly blockAutomationHandler: BlockAutomaticHandler;
+    on: boolean;
+    brightness: number;
+    constructor(deviceId: string, ownDeviceName: string, roomName: string, device: GoveeDevice | undefined);
+    private _color;
+    private _colortemp;
+    private _targetAutomaticState;
+    private _room;
+    get color(): string;
+    get colortemp(): number;
+    get customName(): string;
+    get actuatorOn(): boolean;
+    get lightOn(): boolean;
+    protected _info: DeviceInfo;
+    get info(): DeviceInfo;
+    set info(info: DeviceInfo);
+    get room(): RoomBase;
+    get id(): string;
+    get name(): string;
+    log(level: LogLevel, message: string, debugType?: LogDebugType): void;
+    toJSON(): Partial<OwnGoveeDevice>;
+    persistDeviceInfo(): void;
+    loadDeviceSettings(): void;
+    /**
+     * @inheritDoc
+     */
+    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    /**
+     * @inheritDoc
+     */
+    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, _transitionTime?: number, color?: string, colorTemp?: number): void;
+    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
+    restoreTargetAutomaticValue(): void;
+    private setBrightness;
+    private setColor;
+    private turnOn;
+    private turnOff;
+    persist(): void;
+    toggleActuator(_force: boolean): boolean;
+    toggleLight(time?: TimeOfDay, _force?: boolean, calculateTime?: boolean): boolean;
+    update(data: GoveeDeviceState): void;
+}

package/lib/server/services/govee/own-govee-device.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnGoveeDevice = void 0;
+const devices_1 = require("../../devices");
+const models_1 = require("../../../models");
+const log_service_1 = require("../log-service");
+const utils_1 = require("../utils");
+const lodash_1 = __importDefault(require("lodash"));
+const DeviceCapability_1 = require("../../devices/DeviceCapability");
+const api_1 = require("../api");
+const blockAutomaticHandler_1 = require("../blockAutomaticHandler");
+const time_callback_service_1 = require("../time-callback-service");
+class OwnGoveeDevice {
+    constructor(deviceId, ownDeviceName, roomName, device) {
+        this.device = device;
+        this.settings = new models_1.LedSettings();
+        this.deviceType = devices_1.DeviceType.GoveeLed;
+        this.deviceCapabilities = [
+            DeviceCapability_1.DeviceCapability.lamp,
+            DeviceCapability_1.DeviceCapability.dimmablelamp,
+            DeviceCapability_1.DeviceCapability.blockAutomatic,
+        ];
+        this.on = false;
+        this.brightness = -1;
+        this._color = '#fcba32';
+        this._colortemp = 500;
+        this._targetAutomaticState = false;
+        this._room = undefined;
+        this.deviceId = deviceId;
+        this._info = new devices_1.DeviceInfo();
+        this._info.fullName = `Govee ${roomName} ${ownDeviceName}`;
+        this._info.customName = `Govee ${ownDeviceName}`;
+        this._info.room = roomName;
+        this._info.allDevicesKey = `govee-${roomName}-${deviceId}`;
+        devices_1.Devices.alLDevices[`govee-${roomName}-${deviceId}`] = this;
+        this.persistDeviceInfo();
+        this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this));
+        this.loadDeviceSettings();
+    }
+    get color() {
+        return this._color;
+    }
+    get colortemp() {
+        return this._colortemp;
+    }
+    get customName() {
+        return this.info.customName;
+    }
+    get actuatorOn() {
+        return this.on;
+    }
+    get lightOn() {
+        return this.on;
+    }
+    get info() {
+        return this._info;
+    }
+    set info(info) {
+        this._info = info;
+    }
+    get room() {
+        if (this._room === undefined) {
+            this._room = utils_1.Utils.guard(api_1.API.getRoom(this.info.room));
+        }
+        return this._room;
+    }
+    get id() {
+        var _a;
+        return (_a = this.info.allDevicesKey) !== null && _a !== void 0 ? _a : `govee-${this.info.room}-${this.info.customName}`;
+    }
+    get name() {
+        return this.info.customName;
+    }
+    log(level, message, debugType = log_service_1.LogDebugType.None) {
+        var _a, _b;
+        log_service_1.ServerLogService.writeLog(level, `${this.name}: ${message}`, {
+            debugType: debugType,
+            room: (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.roomName) !== null && _b !== void 0 ? _b : '',
+            deviceId: this.name,
+            deviceName: this.name,
+        });
+    }
+    toJSON() {
+        return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, ['room']));
+    }
+    persistDeviceInfo() {
+        utils_1.Utils.guardedTimeout(() => {
+            var _a;
+            (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.addDevice(this);
+        }, 5000, this);
+    }
+    loadDeviceSettings() {
+        this.settings.initializeFromDb(this);
+    }
+    /**
+     * @inheritDoc
+     */
+    setTimeBased(time, timeout = -1, force = false) {
+        switch (time) {
+            case models_1.TimeOfDay.Night:
+                if (this.settings.nightOn) {
+                    this.setLight(true, timeout, force, this.settings.nightBrightness, undefined, this.settings.nightColor, this.settings.nightColorTemp);
+                }
+                break;
+            case models_1.TimeOfDay.AfterSunset:
+                if (this.settings.duskOn) {
+                    this.setLight(true, timeout, force, this.settings.duskBrightness, undefined, this.settings.duskColor, this.settings.duskColorTemp);
+                }
+                break;
+            case models_1.TimeOfDay.BeforeSunrise:
+                if (this.settings.dawnOn) {
+                    this.setLight(true, timeout, force, this.settings.dawnBrightness, undefined, this.settings.dawnColor, this.settings.dawnColorTemp);
+                }
+                break;
+            case models_1.TimeOfDay.Daylight:
+                if (this.settings.dayOn) {
+                    this.setLight(true, timeout, force, this.settings.dayBrightness, undefined, this.settings.dayColor, this.settings.dayColorTemp);
+                }
+                break;
+        }
+    }
+    /**
+     * @inheritDoc
+     */
+    setLight(pValue, timeout = -1, force, brightness = -1, _transitionTime, color = '', colorTemp = -1) {
+        var _a;
+        if (pValue && brightness === -1 && this.brightness < 10) {
+            brightness = 10;
+        }
+        this.log(models_1.LogLevel.Debug, `LED Schalten An: ${pValue}\tHelligkeit: ${brightness}%\tFarbe: "${color}"\tColorTemperatur: ${colorTemp}`);
+        if (color !== '') {
+            this.setColor(color);
+        }
+        let dontBlock = false;
+        if (force &&
+            this.settings.resetToAutomaticOnForceOffAfterForceOn &&
+            !pValue &&
+            this.blockAutomationHandler.automaticBlockActive) {
+            dontBlock = true;
+            this.log(models_1.LogLevel.Debug, `Reset Automatic Block as we are turning off manually after a force on`);
+            this.blockAutomationHandler.liftAutomaticBlock();
+        }
+        if (!force && this.blockAutomationHandler.automaticBlockActive) {
+            this.log(models_1.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(this.blockAutomationHandler.automaticBlockedUntil).toLocaleTimeString()}`);
+            this._targetAutomaticState = pValue;
+            return;
+        }
+        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}" with brightness ${brightness}`, log_service_1.LogDebugType.SetActuator);
+        if (brightness > -1 && pValue) {
+            this.setBrightness(brightness, () => {
+                this.log(models_1.LogLevel.Debug, `Brightness set to ${brightness}`);
+                this.turnOn();
+            });
+        }
+        else if (pValue) {
+            this.turnOn();
+        }
+        else {
+            this.turnOff();
+        }
+        (_a = this.device) === null || _a === void 0 ? void 0 : _a.actions.setOn();
+        if (timeout > -1 && !dontBlock) {
+            this.blockAutomationHandler.disableAutomatic(timeout, models_1.CollisionSolving.overrideIfGreater);
+        }
+    }
+    setActuator(pValue, timeout, force) {
+        this.setLight(pValue, timeout, force);
+    }
+    restoreTargetAutomaticValue() {
+        this.log(models_1.LogLevel.Debug, `Restore Target Automatic value`);
+        this.setActuator(this._targetAutomaticState);
+    }
+    setBrightness(brightness, cb) {
+        var _a;
+        (_a = this.device) === null || _a === void 0 ? void 0 : _a.actions.setBrightness(brightness).then(() => {
+            cb();
+        }).catch((error) => {
+            this.log(models_1.LogLevel.Error, `Govee set brightness resulted in error: ${error}`);
+        });
+    }
+    setColor(color) {
+        var _a;
+        if (color === this._color) {
+            return;
+        }
+        (_a = this.device) === null || _a === void 0 ? void 0 : _a.actions.setColor({ hex: color }).then(() => {
+            this.log(models_1.LogLevel.Debug, `Govee set color to ${color}`, log_service_1.LogDebugType.SetActuator);
+        }).catch((error) => {
+            this.log(models_1.LogLevel.Error, `Govee set color resulted in error: ${error}`);
+        });
+    }
+    turnOn() {
+        var _a;
+        if (this.on) {
+            return;
+        }
+        (_a = this.device) === null || _a === void 0 ? void 0 : _a.actions.setOn().then(() => {
+            this.log(models_1.LogLevel.Debug, `Govee turned on`, log_service_1.LogDebugType.SetActuator);
+        }).catch((error) => {
+            this.log(models_1.LogLevel.Error, `Govee turn on resulted in error: ${error}`);
+        });
+    }
+    turnOff() {
+        var _a;
+        if (!this.on) {
+            return;
+        }
+        (_a = this.device) === null || _a === void 0 ? void 0 : _a.actions.setOff().then(() => {
+            this.log(models_1.LogLevel.Debug, `Govee turned off`, log_service_1.LogDebugType.SetActuator);
+        }).catch((error) => {
+            this.log(models_1.LogLevel.Error, `Govee turn off resulted in error: ${error}`);
+        });
+    }
+    persist() {
+        var _a;
+        (_a = utils_1.Utils.dbo) === null || _a === void 0 ? void 0 : _a.persistActuator(this);
+    }
+    toggleActuator(_force) {
+        this.setLight(!this.on);
+        return this.on;
+    }
+    toggleLight(time, _force = false, calculateTime = false) {
+        const newVal = !this.lightOn;
+        if (newVal && time === undefined && calculateTime) {
+            time = time_callback_service_1.TimeCallbackService.dayType(this.room.settings.lampOffset);
+        }
+        if (newVal && time !== undefined) {
+            this.setTimeBased(time);
+            return true;
+        }
+        this.setLight(newVal);
+        return newVal;
+    }
+    update(data) {
+        this.on = data.isOn === 1;
+        this.brightness = data.brightness;
+        this._color = `#${data.color.r.toString(16)}${data.color.g.toString(16)}${data.color.b.toString(16)}`;
+        this._colortemp = data.colorKelvin;
+    }
+}
+exports.OwnGoveeDevice = OwnGoveeDevice;

package/lib/server/services/govee/own-govee-devices.d.ts

@@ -0,0 +1,7 @@
+import { OwnGoveeDevice } from './own-govee-device';
+export declare class OwnGoveeDevices {
+    static ownDevices: {
+        [name: string]: OwnGoveeDevice;
+    };
+    static addDevice(device: OwnGoveeDevice): void;
+}

package/lib/server/services/govee/own-govee-devices.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnGoveeDevices = void 0;
+const log_service_1 = require("../log-service");
+const models_1 = require("../../../models");
+class OwnGoveeDevices {
+    static addDevice(device) {
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Device ${device.name} for room "${device.info.room}" addded`);
+        this.ownDevices[device.deviceId] = device;
+    }
+}
+exports.OwnGoveeDevices = OwnGoveeDevices;
+OwnGoveeDevices.ownDevices = {};