hoffmation-base 2.22.18 → 3.0.0-alpha.0

package/lib/server/devices/zigbee/BaseDevices/zigbeeLedRGBCCT.js

@@ -38,34 +38,13 @@ class ZigbeeLedRGBCCT extends zigbeeDimmer_1.ZigbeeDimmer {
     /**
      * @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;
-        }
+    setTimeBased(c) {
+        this.setLight(models_1.LedSetLightCommand.byTimeBased(this.settings, c));
     }
     /**
      * @inheritDoc
      */
-    setLight(pValue, timeout, force, brightness = -1, transitionTime, color = '', colorTemp = -1) {
+    setLight(c) {
         if (this._stateIdState === '') {
             this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
             return;
@@ -74,18 +53,18 @@ class ZigbeeLedRGBCCT extends zigbeeDimmer_1.ZigbeeDimmer {
             this.log(models_1.LogLevel.Error, `Keine Connection bekannt.`);
             return;
         }
-        if (pValue && brightness === -1 && this.brightness < 10) {
-            brightness = 10;
+        if (c.on && c.brightness === -1 && this.brightness < 10) {
+            c.brightness = 10;
         }
-        this.log(models_1.LogLevel.Debug, `LED Schalten An: ${pValue}\tHelligkeit: ${brightness}%\tFarbe: "${color}"\tColorTemperatur: ${colorTemp}\tTransition Time: ${transitionTime}`);
-        const formattedColor = services_1.Utils.formatHex(color);
-        if (formattedColor !== null && pValue) {
+        this.log(models_1.LogLevel.Debug, `LED Schalten An: ${c.on}\tHelligkeit: ${c.brightness}%\tFarbe: "${c.color}"\tColorTemperatur: ${c.colorTemp}\tTransition Time: ${c.transitionTime}`);
+        const formattedColor = services_1.Utils.formatHex(c.color);
+        if (formattedColor !== null && c.on) {
             this.setState(this._stateIdColor, formattedColor);
         }
-        if (colorTemp > -1 && pValue) {
-            this.setState(this._stateIdColorTemp, colorTemp);
+        if (c.colorTemp > -1 && c.on) {
+            this.setState(this._stateIdColorTemp, c.colorTemp);
         }
-        super.setLight(pValue, timeout, force, brightness, transitionTime);
+        super.setLight(c);
     }
 }
 exports.ZigbeeLedRGBCCT = ZigbeeLedRGBCCT;

package/lib/server/devices/zigbee/BaseDevices/zigbeeShutter.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { DeviceType } from '../../deviceType';
-import { ShutterCalibration, ShutterSettings } from '../../../../models';
+import { ShutterCalibration, ShutterSetLevelCommand, ShutterSettings } from '../../../../models';
 import { ZigbeeDevice } from './zigbeeDevice';
 import { iShutter } from '../../baseDeviceInterfaces';
 import { Window } from '../../groups';
@@ -23,7 +23,7 @@ export declare class ZigbeeShutter extends ZigbeeDevice implements iShutter {
     get desiredWindowShutterLevel(): number;
     persist(): void;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, pOverride?: boolean): void;
-    setLevel(pPosition: number, initial?: boolean, skipOpenWarning?: boolean): void;
+    setLevel(c: ShutterSetLevelCommand): void;
     toJSON(): Partial<IoBrokerBaseDevice>;
     protected moveToPosition(pPosition: number): void;
     protected getAverageUp(): number;

package/lib/server/devices/zigbee/BaseDevices/zigbeeShutter.js

@@ -32,7 +32,7 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
         (_b = services_1.Utils.dbo) === null || _b === void 0 ? void 0 : _b.getLastDesiredPosition(this).then((val) => {
             var _a;
             if (val.desiredPosition >= -1) {
-                (_a = this._window) === null || _a === void 0 ? void 0 : _a.setDesiredPosition(val.desiredPosition);
+                (_a = this._window) === null || _a === void 0 ? void 0 : _a.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(models_1.CommandSource.Automatic, val.desiredPosition, 'Found persisted last desired position in DB'));
             }
         });
     }
@@ -74,28 +74,30 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
     update(idSplit, state, initial = false, pOverride = false) {
         super.update(idSplit, state, initial, pOverride);
     }
-    setLevel(pPosition, initial = false, skipOpenWarning = false) {
-        if (!this._firstCommandRecieved && !initial) {
+    setLevel(c) {
+        this.log(models_1.LogLevel.Debug, c.logMessage);
+        let pPosition = c.level;
+        if (!this._firstCommandRecieved && !c.isInitial) {
             this._firstCommandRecieved = true;
         }
-        else if (this._firstCommandRecieved && initial) {
+        else if (this._firstCommandRecieved && c.isInitial) {
             this.log(models_1.LogLevel.Debug, `Skipped initial Rollo  to ${pPosition} as we recieved a command already`);
             return;
         }
-        if (this.currentLevel === pPosition) {
+        if (this.currentLevel === pPosition && !c.isForceAction) {
             this.log(models_1.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`, services_1.LogDebugType.SkipUnchangedRolloPosition);
             return;
         }
         if (this._window !== undefined) {
             if (this._window.griffeInPosition(models_2.WindowPosition.offen) > 0 && pPosition < 100) {
-                if (!skipOpenWarning) {
+                if (!c.skipOpenWarning) {
                     this.log(models_1.LogLevel.Alert, `Not closing the shutter, as the window is open!`);
                 }
                 return;
             }
             if (this._window.griffeInPosition(models_2.WindowPosition.kipp) > 0 && pPosition < 50) {
                 pPosition = 50;
-                if (!skipOpenWarning) {
+                if (!c.skipOpenWarning) {
                     this.log(models_1.LogLevel.Alert, `Not closing the shutter, as the window is half open!`);
                 }
             }

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

@@ -71,10 +71,10 @@ class ZigbeeBlitzShp extends BaseDevices_1.ZigbeeActuator {
     }
     turnOnForExcessEnergy() {
         this._activatedByExcessEnergy = true;
-        this.setActuator(true);
+        this.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Automatic, true, 'Turn on for excess energy'));
     }
     turnOffDueToMissingEnergy() {
-        this.setActuator(false);
+        this.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.Automatic, false, 'Turn off due to missing energy'));
     }
     wasActivatedByExcessEnergy() {
         return this._activatedByExcessEnergy;

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

@@ -99,7 +99,7 @@ class ZigbeeHeimanSmoke extends BaseDevices_1.ZigbeeDevice {
         });
         services_1.Utils.guardedNewThread(() => {
             // Roll all Rollos up, to ensure free sight for firefighters
-            services_1.RoomService.setAllRolloOfFloor(-1, 100);
+            services_1.RoomService.setAllShutterOfFloor(new models_1.FloorSetAllShuttersCommand(models_1.CommandSource.Force, 100, undefined, 'Fire alarm'));
         });
     }
     persistBatteryDevice() {

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

@@ -5,6 +5,4 @@ export declare class ZigbeeIlluActuator extends ZigbeeActuator {
     constructor(pInfo: IoBrokerDeviceInfo, deviceType?: DeviceType);
     get isActuatorOn(): boolean;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
-    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleActuator(force?: boolean): boolean;
 }

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

@@ -17,11 +17,5 @@ class ZigbeeIlluActuator extends BaseDevices_1.ZigbeeActuator {
         }
         super.update(idSplit, state, initial, true);
     }
-    setActuator(pValue, timeout = -1, force = false) {
-        super.setActuator(pValue, timeout, force);
-    }
-    toggleActuator(force = false) {
-        return super.toggleActuator(force);
-    }
 }
 exports.ZigbeeIlluActuator = ZigbeeIlluActuator;

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

@@ -1,5 +1,5 @@
 import { ZigbeeIlluActuator } from './zigbeeIlluActuator';
-import { TimeOfDay } from '../../../models';
+import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
 import { iLamp } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 export declare class ZigbeeIlluLampe extends ZigbeeIlluActuator implements iLamp {
@@ -7,8 +7,8 @@ export declare class ZigbeeIlluLampe extends ZigbeeIlluActuator implements iLamp
     get lightOn(): boolean;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     /** @inheritdoc */
-    setLight(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setLight(c: LampSetLightCommand): void;
+    toggleLight(c: LampToggleLightCommand): boolean;
+    setTimeBased(c: LampSetTimeBasedCommand): void;
     persist(): void;
 }

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

@@ -24,19 +24,14 @@ class ZigbeeIlluLampe extends zigbeeIlluActuator_1.ZigbeeIlluActuator {
         }
     }
     /** @inheritdoc */
-    setLight(pValue, timeout = -1, force = false) {
-        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}"`, services_1.LogDebugType.SetActuator);
-        if (this.settings.isStromStoss && pValue) {
-            timeout = 3000;
-            sharedFunctions_1.LampUtils.stromStossOn(this);
-        }
-        super.setActuator(pValue, timeout, force);
+    setLight(c) {
+        super.setActuator(c);
     }
-    toggleLight(time, force = false, calculateTime = false) {
-        return sharedFunctions_1.LampUtils.toggleLight(this, time, force, calculateTime);
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
     }
-    setTimeBased(time, timeout = -1, force = false) {
-        sharedFunctions_1.LampUtils.setTimeBased(this, time, timeout, force);
+    setTimeBased(c) {
+        sharedFunctions_1.LampUtils.setTimeBased(this, c);
     }
     persist() {
         var _a;

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

@@ -13,8 +13,4 @@ export declare class ZigbeeInnr142C extends ZigbeeLedRGBCCT {
     protected readonly _stateNameColorTemp: string;
     protected readonly _debounceStateDelay: number;
     constructor(pInfo: IoBrokerDeviceInfo);
-    /**
-     * @inheritDoc
-     */
-    setLight(pValue: boolean, timeout?: number, force?: boolean, brightness?: number, transitionTime?: number, color?: string, colorTemp?: number): void;
 }

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

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZigbeeInnr142C = void 0;
 const deviceType_1 = require("../deviceType");
 const BaseDevices_1 = require("./BaseDevices");
-const models_1 = require("../../../models");
-const services_1 = require("../../services");
 class ZigbeeInnr142C extends BaseDevices_1.ZigbeeLedRGBCCT {
     constructor(pInfo) {
         super(pInfo, deviceType_1.DeviceType.ZigbeeInnr142C);
@@ -20,36 +18,5 @@ class ZigbeeInnr142C extends BaseDevices_1.ZigbeeLedRGBCCT {
         this._stateIdState = `${this.info.fullID}.state`;
         this._stateIdTransitionTime = `${this.info.fullID}.transition_time`;
     }
-    /**
-     * @inheritDoc
-     */
-    setLight(pValue, timeout, force, brightness = -1, transitionTime, color = '', colorTemp = -1) {
-        if (this._stateIdState === '') {
-            this.log(models_1.LogLevel.Error, `Keine State ID bekannt.`);
-            return;
-        }
-        if (!this.ioConn) {
-            this.log(models_1.LogLevel.Error, `Keine Connection bekannt.`);
-            return;
-        }
-        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}\tTransition Time: ${transitionTime}`);
-        if (this._lightOn !== pValue || this._brightness !== brightness) {
-            super.setLight(pValue, timeout, force, brightness, transitionTime);
-        }
-        const formattedColor = services_1.Utils.formatHex(color);
-        if (!pValue) {
-            return;
-        }
-        // Farben nur beim Einschalten setzen
-        if (formattedColor !== null && this.color !== formattedColor) {
-            this.setState(this._stateIdColor, formattedColor);
-        }
-        if (colorTemp > -1 && this.colortemp !== colorTemp) {
-            this.setState(this._stateIdColorTemp, colorTemp);
-        }
-    }
 }
 exports.ZigbeeInnr142C = ZigbeeInnr142C;

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

@@ -8,6 +8,4 @@ export declare class ZigbeeUbisysActuator extends ZigbeeActuator implements iLoa
     get isActuatorOn(): boolean;
     get loadPower(): number;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean, handledByChildObject?: boolean): void;
-    setActuator(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleActuator(force?: boolean): boolean;
 }

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

@@ -30,11 +30,5 @@ class ZigbeeUbisysActuator extends BaseDevices_1.ZigbeeActuator {
         }
         super.update(idSplit, state, initial, true);
     }
-    setActuator(pValue, timeout = -1, force = false) {
-        super.setActuator(pValue, timeout, force);
-    }
-    toggleActuator(force = false) {
-        return super.toggleActuator(force);
-    }
 }
 exports.ZigbeeUbisysActuator = ZigbeeUbisysActuator;

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

@@ -1,4 +1,4 @@
-import { TimeOfDay } from '../../../models';
+import { LampSetLightCommand, LampSetTimeBasedCommand, LampToggleLightCommand } from '../../../models';
 import { iLamp } from '../baseDeviceInterfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { ZigbeeUbisysActuator } from './zigbeeUbisysActuator';
@@ -7,8 +7,8 @@ export declare class ZigbeeUbisysLampe extends ZigbeeUbisysActuator implements i
     get lightOn(): boolean;
     update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
     /** @inheritdoc */
-    setLight(pValue: boolean, timeout?: number, force?: boolean): void;
-    toggleLight(time?: TimeOfDay, force?: boolean, calculateTime?: boolean): boolean;
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setLight(c: LampSetLightCommand): void;
+    toggleLight(c: LampToggleLightCommand): boolean;
+    setTimeBased(c: LampSetTimeBasedCommand): void;
     persist(): void;
 }

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

@@ -24,19 +24,14 @@ class ZigbeeUbisysLampe extends zigbeeUbisysActuator_1.ZigbeeUbisysActuator {
         }
     }
     /** @inheritdoc */
-    setLight(pValue, timeout = -1, force = false) {
-        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}"`, services_1.LogDebugType.SetActuator);
-        if (this.settings.isStromStoss && pValue) {
-            timeout = 3000;
-            sharedFunctions_1.LampUtils.stromStossOn(this);
-        }
-        super.setActuator(pValue, timeout, force);
+    setLight(c) {
+        super.setActuator(c);
     }
-    toggleLight(time, force = false, calculateTime = false) {
-        return sharedFunctions_1.LampUtils.toggleLight(this, time, force, calculateTime);
+    toggleLight(c) {
+        return sharedFunctions_1.LampUtils.toggleLight(this, c);
     }
-    setTimeBased(time, timeout = -1, force = false) {
-        sharedFunctions_1.LampUtils.setTimeBased(this, time, timeout, force);
+    setTimeBased(c) {
+        sharedFunctions_1.LampUtils.setTimeBased(this, c);
     }
     persist() {
         var _a;

package/lib/server/services/ShutterService.d.ts

@@ -1,13 +1,8 @@
 import { iShutter, Window } from '../devices';
+import { ShutterSetLevelCommand } from '../../models';
 export declare class ShutterService {
     static anyRolloDown(rollo: iShutter[]): boolean;
     static getRolladenPosition(): string;
     static getAllRollos(): iShutter[];
-    static down(shutter: iShutter, initial?: boolean): void;
-    static middle(shutter: iShutter): void;
-    static up(shutter: iShutter, initial?: boolean): void;
-    static windowAllDown(f: Window, initial?: boolean): void;
-    static windowAllMiddle(f: Window, initial?: boolean): void;
-    static windowAllUp(f: Window, initial?: boolean): void;
-    static windowAllToPosition(f: Window, position: number, initial?: boolean, skipOpenWarning?: boolean): void;
+    static windowAllToPosition(f: Window, c: ShutterSetLevelCommand): void;
 }

package/lib/server/services/ShutterService.js

@@ -52,33 +52,9 @@ class ShutterService {
         }
         return rollos;
     }
-    static down(shutter, initial = false) {
-        shutter.setLevel(0, initial);
-    }
-    static middle(shutter) {
-        shutter.setLevel(50, false);
-    }
-    static up(shutter, initial = false) {
-        shutter.setLevel(100, initial);
-    }
-    static windowAllDown(f, initial = false) {
-        f.getShutter().forEach((s) => {
-            s.setLevel(0, initial);
-        });
-    }
-    static windowAllMiddle(f, initial = false) {
-        f.getShutter().forEach((s) => {
-            s.setLevel(50, initial);
-        });
-    }
-    static windowAllUp(f, initial = false) {
-        f.getShutter().forEach((s) => {
-            s.setLevel(100, initial);
-        });
-    }
-    static windowAllToPosition(f, position, initial = false, skipOpenWarning = false) {
+    static windowAllToPosition(f, c) {
         f.getShutter().forEach((s) => {
-            s.setLevel(position, initial, skipOpenWarning);
+            s.setLevel(c);
         });
     }
 }

package/lib/server/services/Telegram/telegram-Commands.js

@@ -6,6 +6,7 @@ const telegramMessageCalback_1 = require("./telegramMessageCalback");
 const ShutterService_1 = require("../ShutterService");
 const telegram_service_1 = require("./telegram-service");
 const room_service_1 = require("../room-service");
+const models_1 = require("../../../models");
 class TelegramCommands {
     static initialize() {
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AlarmStop', /\/stop_alarm/, async (m) => {
@@ -81,7 +82,7 @@ class TelegramCommands {
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AllRolloDown', /\/all_rollo_down/, async (m) => {
             if (m.from === undefined)
                 return false;
-            room_service_1.RoomService.setAllRolloOfFloor(-1, 0);
+            room_service_1.RoomService.setAllShutterOfFloor(new models_1.FloorSetAllShuttersCommand(models_1.CommandSource.Manual, 0, undefined, 'Telegram command AllRolloDown'));
             telegram_service_1.TelegramService.sendMessage([m.chat.id], `Es werden alle Rollos heruntergefahren`);
             return true;
         }, `Fährt alle rollos runter`));

package/lib/server/services/ac/daikin-service.d.ts

@@ -12,7 +12,7 @@ export declare class DaikinService {
     static getDevice(name: string): DaikinAC | undefined;
     static initialize(): Promise<void>;
     static setAll(on: boolean, force?: boolean): void;
-    static reconnect(name: string, ip: string): Promise<DaikinAC | undefined>;
+    static reconnect(name: string, ip: string, mac?: string): Promise<DaikinAC | undefined>;
     private static reconstructDaikinAc;
     private static initializeDevice;
 }

package/lib/server/services/ac/daikin-service.js

@@ -85,13 +85,18 @@ class DaikinService {
             }
         }
     }
-    static async reconnect(name, ip) {
+    static async reconnect(name, ip, mac) {
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Reconnecting Daikin AC "${name}"`);
         const router = network_1.Router.getRouter();
         if (router === undefined) {
             return this.reconstructDaikinAc(ip, name);
         }
-        await router.reconnectDeviceByIp(ip);
+        if (mac !== undefined) {
+            await router.reconnectDeviceByMac(mac);
+        }
+        else {
+            await router.reconnectDeviceByIp(ip);
+        }
         await utils_1.Utils.delay(5000);
         return this.reconstructDaikinAc(ip, name);
     }

package/lib/server/services/ac/own-daikin-device.d.ts

@@ -3,13 +3,14 @@ import { AcDevice } from './ac-device';
 import { AcMode } from './ac-mode';
 import { DeviceType } from '../../devices';
 export declare class OwnDaikinDevice extends AcDevice {
+    private _device;
+    private _mac;
     desiredState: boolean;
     desiredHum: number | 'AUTO';
     desiredMode: number;
     deviceType: DeviceType;
     private _on;
-    constructor(name: string, roomName: string, ip: string, device: DaikinAC | undefined);
-    private _device;
+    constructor(name: string, roomName: string, ip: string, _device: DaikinAC | undefined, _mac?: string | undefined);
     get device(): DaikinAC | undefined;
     get on(): boolean;
     set device(device: DaikinAC | undefined);

package/lib/server/services/ac/own-daikin-device.js

@@ -16,14 +16,15 @@ const acDeviceType_1 = require("./acDeviceType");
 const devices_1 = require("../../devices");
 const lodash_1 = __importDefault(require("lodash"));
 class OwnDaikinDevice extends ac_device_1.AcDevice {
-    constructor(name, roomName, ip, device) {
+    constructor(name, roomName, ip, _device, _mac = undefined) {
         super(name, roomName, ip, acDeviceType_1.AcDeviceType.Daikin);
+        this._device = _device;
+        this._mac = _mac;
         this.desiredState = daikin_controller_1.Power.OFF;
         this.desiredHum = 'AUTO';
         this.desiredMode = daikin_controller_1.Mode.COLD;
         this.deviceType = devices_1.DeviceType.Daikin;
         this._on = false;
-        this._device = device;
     }
     get device() {
         return this._device;
@@ -138,7 +139,7 @@ class OwnDaikinDevice extends ac_device_1.AcDevice {
     }
     handleDeviceUnreach() {
         this.log(models_1.LogLevel.Warn, `Detected EHOSTUNREACH for ${this.name}(${this.ip}), will try reconecting`);
-        daikin_service_1.DaikinService.reconnect(this.name, this.ip)
+        daikin_service_1.DaikinService.reconnect(this.name, this.ip, this._mac)
             .then((device) => {
             this.device = device;
             utils_1.Utils.guardedTimeout(() => {

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

@@ -121,7 +121,7 @@ class API {
             return new Error(`Device with ID ${deviceId} is no Lamp`);
         }
         d.log(models_1.LogLevel.Info, `API Call to set Lamp to ${state} for ${timeout}ms`);
-        d.setLight(state, timeout, true);
+        d.setLight(new models_1.LampSetLightCommand(models_1.CommandSource.API, state, '', timeout));
         return null;
     }
     /**
@@ -140,7 +140,7 @@ class API {
             return new Error(`Device with ID ${deviceId} is no actuator`);
         }
         d.log(models_1.LogLevel.Info, `API Call to set Actuator to ${state} for ${timeout}ms`);
-        d.setActuator(state, timeout, true);
+        d.setActuator(new models_1.ActuatorSetStateCommand(models_1.CommandSource.API, state, '', timeout));
         return null;
     }
     /**
@@ -161,7 +161,7 @@ class API {
             return new Error(`Device with ID ${deviceId} is no dimmablelamp`);
         }
         d.log(models_1.LogLevel.Info, `API Call to set Dimmer to ${state} with brightness ${brightness} for ${timeout}ms`);
-        d.setLight(state, timeout, true, brightness, transitionTime);
+        d.setLight(new models_1.DimmerSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime));
         return null;
     }
     /**
@@ -184,7 +184,7 @@ class API {
             return new Error(`Device with ID ${deviceId} is no dimmablelamp`);
         }
         d.log(models_1.LogLevel.Info, `API Call to set LED to ${state} with brightness ${brightness} and color ${color} for ${timeout}ms`);
-        d.setLight(state, timeout, true, brightness, transitionTime, color, colorTemp);
+        d.setLight(new models_1.LedSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime, color, colorTemp));
         return null;
     }
     /**
@@ -204,10 +204,10 @@ class API {
         }
         if (d.window) {
             // otherwise it will be overridden shortly after
-            d.window.setDesiredPosition(level);
+            d.window.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(models_1.CommandSource.API, level));
         }
         else {
-            d.setLevel(level, false);
+            d.setLevel(new models_1.ShutterSetLevelCommand(models_1.CommandSource.API, level));
         }
         d.log(models_1.LogLevel.Info, `API Call to set Shutter to ${level}`);
         return null;

package/lib/server/services/blockAutomaticHandler.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import { CollisionSolving } from '../../models';
+import { CollisionSolving, RestoreTargetAutomaticValueCommand } from '../../models';
 export declare class BlockAutomaticHandler {
     private readonly _restoreAutomatic;
-    constructor(restoreAutomaticCb: () => void);
+    constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void);
     private _automaticBlockedUntil;
     get automaticBlockedUntil(): Date;
     private set automaticBlockedUntil(value);

package/lib/server/services/blockAutomaticHandler.js

@@ -36,16 +36,18 @@ class BlockAutomaticHandler {
             (onCollideAction != models_1.CollisionSolving.overrideIfGreater || targetDate < this._automaticBlockedUntil)) {
             return;
         }
-        this._automaticBlockedUntil = targetDate;
+        this.automaticBlockedUntil = targetDate;
     }
     liftAutomaticBlock() {
-        this._automaticBlockedUntil = new Date(0);
+        this.automaticBlockedUntil = new Date(0);
     }
     updateRestoreTimeout() {
         if (this._restoreAutomaticStateTimeout !== null) {
             clearTimeout(this._restoreAutomaticStateTimeout);
         }
-        this._restoreAutomaticStateTimeout = utils_1.Utils.guardedTimeout(this._restoreAutomatic, this._automaticBlockedUntil.getTime() - utils_1.Utils.nowMS() + 500, this);
+        this._restoreAutomaticStateTimeout = utils_1.Utils.guardedTimeout(() => {
+            this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(models_1.CommandSource.Unknown, 'Automatic block restore timeout'));
+        }, this._automaticBlockedUntil.getTime() - utils_1.Utils.nowMS() + 500, this);
     }
     toJSON() {
         return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, ['_restoreAutomatic']));

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

@@ -1,5 +1,5 @@
 import { DeviceInfo, DeviceType, iTemporaryDisableAutomatic } from '../../devices';
-import { LedSettings, LogLevel, RoomBase, TimeOfDay } from '../../../models';
+import { ActuatorSetStateCommand, ActuatorToggleCommand, ActuatorWriteStateToDeviceCommand, LampSetTimeBasedCommand, LampToggleLightCommand, LedSetLightCommand, LedSettings, LogLevel, RestoreTargetAutomaticValueCommand, RoomBase } from '../../../models';
 import { LogDebugType } from '../log-service';
 import { DeviceCapability } from '../../devices/DeviceCapability';
 import { iLedRgbCct } from '../../devices/baseDeviceInterfaces/iLedRgbCct';
@@ -39,16 +39,17 @@ export declare class OwnGoveeDevice implements iLedRgbCct, iTemporaryDisableAuto
     /**
      * @inheritDoc
      */
-    setTimeBased(time: TimeOfDay, timeout?: number, force?: boolean): void;
+    setTimeBased(c: LampSetTimeBasedCommand): 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;
+    setLight(c: LedSetLightCommand): void;
+    setActuator(c: ActuatorSetStateCommand): void;
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     persist(): void;
-    toggleActuator(_force: boolean): boolean;
-    toggleLight(time?: TimeOfDay, _force?: boolean, calculateTime?: boolean): boolean;
+    toggleActuator(c: ActuatorToggleCommand): boolean;
+    toggleLight(c: LampToggleLightCommand): boolean;
+    writeActuatorStateToDevice(c: ActuatorWriteStateToDeviceCommand): void;
     update(data: GoveeDeviceState & GoveeDeviceStateInfo): void;
     private setBrightness;
     private setColor;