hoffmation-base 3.0.0-alpha.19 → 3.0.0-alpha.20

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

@@ -39,10 +39,12 @@ class API {
         }
         return result;
     }
+    // TODO: Missing Comment
     static getDevices() {
         // console.log(Util.inspect(Devices.alLDevices, false, 5));
         return devices_1.Devices.alLDevices;
     }
+    // TODO: Missing Comment
     static getDevice(id) {
         const d = devices_1.Devices.alLDevices[id];
         if (d === undefined) {
@@ -50,6 +52,7 @@ class API {
         }
         return devices_1.Devices.alLDevices[id];
     }
+    // TODO: Missing Comment
     static getGroup(id) {
         const g = room_service_1.RoomService.Groups.get(id);
         if (g === undefined) {
@@ -57,13 +60,16 @@ class API {
         }
         return g;
     }
+    // TODO: Missing Comment
     static getRooms() {
         // console.log(inspect(Object.fromEntries(RoomService.Rooms)));
         return room_service_1.RoomService.Rooms;
     }
+    // TODO: Missing Comment
     static getRoom(id) {
         return room_service_1.RoomService.Rooms.get(id);
     }
+    // TODO: Missing Comment
     static getLog() {
         return log_service_1.ServerLogService.getLog();
     }
@@ -107,12 +113,23 @@ class API {
     }
     /**
      * Changes the status of a given Lamp
+     * @deprecated Use "API.lampSetLight" instead
+     * TODO: Remove deprecated API method
      * @param {string} deviceId The device Id of the lamp
      * @param {boolean} state The desired new state
      * @param timeout Desired time after which this should be reverted to normal state
      * @returns {Error | null} In case it failed the Error containing the reason
      */
     static setLamp(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.lampSetLight(deviceId, new models_1.LampSetLightCommand(models_1.CommandSource.API, state, '', timeout));
+    }
+    /**
+     * Changes the status of a given Lamp
+     * @param {string} deviceId The device Id of the lamp
+     * @param {LampSetLightCommand} c The command(stack) to perform on the lamp
+     * @returns {Error | null} In case it failed the Error containing the reason.
+     */
+    static lampSetLight(deviceId, c) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -120,18 +137,29 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.lamp)) {
             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(new models_1.LampSetLightCommand(models_1.CommandSource.API, state, '', timeout));
+        d.log(models_1.LogLevel.Info, `Received LampSetLightCommand API call.`);
+        d.setLight(c);
         return null;
     }
     /**
      * Changes the status of a given actuator
+     * @deprecated Use "API.actuatorSetState" instead
+     * TODO: Remove deprecated API method
      * @param {string} deviceId The device Id of the actuator
      * @param {boolean} state The desired new state
      * @param timeout Desired time after which this should be reverted to automatic state
      * @returns {Error | null} In case it failed the Error containing the reason
      */
     static setActuator(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.actuatorSetState(deviceId, new models_1.ActuatorSetStateCommand(models_1.CommandSource.API, state, '', timeout));
+    }
+    /**
+     * Changes the status of a given actuator
+     * @param {string} deviceId The device Id of the actuator
+     * @param {ActuatorSetStateCommand} c The command(stack) to perform on the actuator
+     * @returns {Error | null} In case it failed the Error containing the reason
+     */
+    static actuatorSetState(deviceId, c) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -139,12 +167,14 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.actuator)) {
             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(new models_1.ActuatorSetStateCommand(models_1.CommandSource.API, state, '', timeout));
+        d.log(models_1.LogLevel.Info, `Received ActuatorSetStateCommand API call.`);
+        d.setActuator(c);
         return null;
     }
     /**
-     * Changes the status of a given actuator
+     * Changes the status of the given dimmer
+     * @deprecated Use "API.dimmerSetLight" instead
+     * TODO: Remove deprecated API method
      * @param {string} deviceId The device Id of the actuator
      * @param {boolean} state The desired new state
      * @param timeout A chosen Timeout after which the light should be reset
@@ -153,6 +183,15 @@ class API {
      * @returns {Error | null} In case it failed the Error containing the reason
      */
     static setDimmer(deviceId, state, timeout, brightness, transitionTime) {
+        return this.dimmerSetLight(deviceId, new models_1.DimmerSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime));
+    }
+    /**
+     * Changes the status of the given dimmer
+     * @param {string} deviceId The device Id of the dimmable device.
+     * @param {DimmerSetLightCommand} command The command(stack) to perform on the dimmer
+     * @returns {Error | null} In case it failed the Error containing the reason.
+     */
+    static dimmerSetLight(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -160,12 +199,14 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.dimmablelamp)) {
             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(new models_1.DimmerSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime));
+        d.log(models_1.LogLevel.Info, `Received dimmerSetLight API call.`);
+        d.setLight(command);
         return null;
     }
     /**
-     * Changes the status of a given actuator
+     * Changes the status of a given led-device
+     * @deprecated Use "API.ledSetLight" instead
+     * TODO: Remove deprecated API method
      * @param {string} deviceId The device Id of the actuator
      * @param {boolean} state The desired new state
      * @param timeout A chosen Timeout after which the light should be reset
@@ -176,25 +217,45 @@ class API {
      * @returns {Error | null} In case it failed the Error containing the reason
      */
     static setLedLamp(deviceId, state, timeout, brightness, transitionTime, color, colorTemp) {
+        return this.ledSetLight(deviceId, new models_1.LedSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime, color, colorTemp));
+    }
+    /**
+     * Changes the status of a given led-device
+     * @param {string} deviceId The device Id of the LED-Device
+     * @param {LedSetLightCommand} command The command(stack) to perform on the led-device
+     */
+    static ledSetLight(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
         }
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.ledLamp)) {
-            return new Error(`Device with ID ${deviceId} is no dimmablelamp`);
+            return new Error(`Device with ID ${deviceId} is no LED`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to set LED to ${state} with brightness ${brightness} and color ${color} for ${timeout}ms`);
-        d.setLight(new models_1.LedSetLightCommand(models_1.CommandSource.API, state, '', timeout, brightness, transitionTime, color, colorTemp));
+        d.log(models_1.LogLevel.Info, `Received ledSetLight API call.`);
+        d.setLight(command);
         return null;
     }
     /**
      * Changes the position of a given shutter
      * if needed this updates the window position as well
+     * @deprecated Use "API.shutterSetLevel" instead
+     * TODO: Remove deprecated API method
      * @param {string} deviceId The device Id of the shutter
      * @param {number} level The desired new level (0 being open, 100 being closed)
      * @returns {Error | null} Error if there is no shutter with the given id
      */
     static setShutter(deviceId, level) {
+        return this.shutterSetLevel(deviceId, new models_1.ShutterSetLevelCommand(models_1.CommandSource.API, level));
+    }
+    /**
+     * Changes the position of a given shutter
+     * if needed this updates the window position as well
+     * @param {string} deviceId The device Id of the shutter
+     * @param {ShutterSetLevelCommand} command The command(stack) to perform on the shutter
+     * @returns {Error | null} Error if there is no shutter with the given id
+     */
+    static shutterSetLevel(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -204,14 +265,15 @@ class API {
         }
         if (d.window) {
             // otherwise it will be overridden shortly after
-            d.window.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(models_1.CommandSource.API, level));
+            d.window.setDesiredPosition(new models_1.WindowSetDesiredPositionCommand(command, command.level));
         }
         else {
-            d.setLevel(new models_1.ShutterSetLevelCommand(models_1.CommandSource.API, level));
+            d.setLevel(command);
         }
-        d.log(models_1.LogLevel.Info, `API Call to set Shutter to ${level}`);
+        d.log(models_1.LogLevel.Info, `Received shutterSetLevel API call.`);
         return null;
     }
+    // TODO: Missing Comment
     static speakOnDevice(deviceId, message, volume = 30) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
@@ -279,6 +341,7 @@ class API {
         d.settings.persist(d);
         return null;
     }
+    // TODO: Missing Comment
     static setGroupSettings(groupId, settings) {
         const g = this.getGroup(groupId);
         if (g === undefined) {
@@ -308,6 +371,7 @@ class API {
         r.settings.settingsContainer.persist(r);
         return null;
     }
+    // TODO: Missing Comment
     static getLastCameraImage(deviceId) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
@@ -318,6 +382,7 @@ class API {
         }
         return d.lastImage;
     }
+    // TODO: Missing Comment
     static persistAllDeviceSettings() {
         var _a;
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `API Call to persist all device settings`);
@@ -325,6 +390,7 @@ class API {
             (_a = device.settings) === null || _a === void 0 ? void 0 : _a.persist(device);
         }
     }
+    // TODO: Missing Comment
     static loadAllDeviceSettingsFromDb() {
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `API Call to load all device settings`);
         for (const device of Object.values(devices_1.Devices.alLDevices)) {
@@ -333,10 +399,21 @@ class API {
     }
     /**
      * Lifts a previously started Block of automatic
+     * @deprecated Use "API.blockAutomaticLiftAutomaticBlock" instead
+     * TODO: Remove deprecated API method
      * @param {string} deviceId The target device
      * @returns {Error | null} In case it failed the Error containing the reason
      */
     static liftAutomaticBlock(deviceId) {
+        return this.blockAutomaticLiftAutomaticBlock(deviceId, new models_1.BlockAutomaticLiftBlockCommand(models_1.CommandSource.API));
+    }
+    /**
+     * Lifts a previously started Block of automatic
+     * @param {string} deviceId The target device
+     * @param {BlockAutomaticLiftBlockCommand} command The command to lift the automatic block
+     * @returns {Error | null} In case it failed the Error containing the reason
+     */
+    static blockAutomaticLiftAutomaticBlock(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -344,18 +421,30 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.blockAutomatic)) {
             return new Error(`Device with ID ${deviceId} is not capable of blocking automatic`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to lift automatic block`);
-        d.blockAutomationHandler.liftAutomaticBlock();
+        d.log(models_1.LogLevel.Info, `Received API Call to lift automatic block.`);
+        d.blockAutomationHandler.liftAutomaticBlock(command);
         return null;
     }
     /**
      * Blocks the automatic of the given device for provided Duration
+     * @deprecated Use "API.blockAutomaticDisable" instead
+     * TODO: Remove deprecated API method
      * @param {string} deviceId The target device
      * @param {number} duration The duration in ms for which the device should remain in current state
      * @param {CollisionSolving} onCollision The desired Collision Solving strategy, in case the automatic being blocked already
      * @returns {Error | null} In case it failed the Error containing the reason
      */
     static blockAutomatic(deviceId, duration, onCollision) {
+        this.blockAutomaticSetBlock(deviceId, new models_1.BlockAutomaticCommand(models_1.CommandSource.API, duration, '', onCollision));
+        return null;
+    }
+    /**
+     * Blocks the automatic of the given device for provided Duration
+     * @param {string} deviceId The target device
+     * @param {BlockAutomaticCommand} command The command to block the automatic
+     * @returns {Error | null} In case it failed the Error containing the reason
+     */
+    static blockAutomaticSetBlock(deviceId, command) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {
             return new Error(`Device with ID ${deviceId} not found`);
@@ -363,10 +452,11 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.blockAutomatic)) {
             return new Error(`Device with ID ${deviceId} is not capable of blocking automatic`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to block automatic for ${duration}ms with ${onCollision} on collision`);
-        d.blockAutomationHandler.disableAutomatic(duration, onCollision);
+        d.log(models_1.LogLevel.Info, `Received API Call to block automatic.`);
+        d.blockAutomationHandler.disableAutomatic(command);
         return null;
     }
+    // TODO: Missing Comment
     static pressButtonSwitch(deviceId, position, pressType) {
         const d = this.getDevice(deviceId);
         if (d === undefined) {

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

@@ -1,18 +1,15 @@
-/// <reference types="node" />
-import { CollisionSolving, RestoreTargetAutomaticValueCommand } from '../../models';
+import { BlockAutomaticCommand, BlockAutomaticLiftBlockCommand, BlockAutomaticUntilCommand, RestoreTargetAutomaticValueCommand } from '../../models';
 export declare class BlockAutomaticHandler {
     private readonly _restoreAutomatic;
-    private _delayedLiftTimeout;
-    constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void);
     private _automaticBlockedUntil;
+    private _restoreAutomaticStateTimeout;
+    constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void);
     get automaticBlockedUntil(): Date;
     private set automaticBlockedUntil(value);
-    private _restoreAutomaticStateTimeout;
-    get restoreAutomaticStateTimeout(): NodeJS.Timeout | null;
     get automaticBlockActive(): boolean;
-    disableAutomatic(durationMS: number, onCollideAction?: CollisionSolving): void;
-    disableAutomaticUntil(targetDate: Date, onCollideAction?: CollisionSolving): void;
-    liftAutomaticBlock(delay?: number): void;
+    disableAutomatic(c: BlockAutomaticCommand): void;
+    disableAutomaticUntil(c: BlockAutomaticUntilCommand): void;
+    liftAutomaticBlock(c: BlockAutomaticLiftBlockCommand): void;
     private updateRestoreTimeout;
     toJSON(): Partial<BlockAutomaticHandler>;
 }

package/lib/server/services/blockAutomaticHandler.js

@@ -9,7 +9,6 @@ const utils_1 = require("./utils");
 const lodash_1 = __importDefault(require("lodash"));
 class BlockAutomaticHandler {
     constructor(restoreAutomaticCb) {
-        this._delayedLiftTimeout = null;
         this._automaticBlockedUntil = new Date(0);
         this._restoreAutomaticStateTimeout = null;
         this._restoreAutomatic = restoreAutomaticCb;
@@ -19,49 +18,32 @@ class BlockAutomaticHandler {
     }
     set automaticBlockedUntil(target) {
         this._automaticBlockedUntil = target;
-        this.updateRestoreTimeout();
-    }
-    get restoreAutomaticStateTimeout() {
-        return this._restoreAutomaticStateTimeout;
     }
     get automaticBlockActive() {
         return this._automaticBlockedUntil > new Date();
     }
-    disableAutomatic(durationMS, onCollideAction = models_1.CollisionSolving.overrideIfGreater) {
-        this.disableAutomaticUntil(new Date(utils_1.Utils.nowMS() + durationMS), onCollideAction);
+    disableAutomatic(c) {
+        this.disableAutomaticUntil(new models_1.BlockAutomaticUntilCommand(c, new Date(utils_1.Utils.nowMS() + c.durationMS), '', c.onCollideAction));
     }
-    disableAutomaticUntil(targetDate, onCollideAction = models_1.CollisionSolving.overrideIfGreater) {
+    disableAutomaticUntil(c) {
         const now = new Date();
         if (this._automaticBlockedUntil > now &&
-            onCollideAction != models_1.CollisionSolving.override &&
-            (onCollideAction != models_1.CollisionSolving.overrideIfGreater || targetDate < this._automaticBlockedUntil)) {
+            c.onCollideAction != models_1.CollisionSolving.override &&
+            (c.onCollideAction != models_1.CollisionSolving.overrideIfGreater || c.targetDate < this._automaticBlockedUntil)) {
             return;
         }
-        this.automaticBlockedUntil = targetDate;
+        this.automaticBlockedUntil = c.targetDate;
+        this.updateRestoreTimeout(new models_1.RestoreTargetAutomaticValueCommand(c, 'Restore to automatic state after block.'));
     }
-    // TODO: Missing conversion to command
-    liftAutomaticBlock(delay = 0) {
-        if (delay <= 0) {
-            this.automaticBlockedUntil = new Date(0);
-            return;
-        }
-        if (this._delayedLiftTimeout !== null) {
-            return;
-        }
-        const currentBlockedUntil = this._automaticBlockedUntil;
-        this._delayedLiftTimeout = utils_1.Utils.guardedTimeout(() => {
-            this._delayedLiftTimeout = null;
-            if (this.automaticBlockActive && this._automaticBlockedUntil.getTime() === currentBlockedUntil.getTime()) {
-                this.liftAutomaticBlock(0);
-            }
-        }, delay, this);
+    liftAutomaticBlock(c) {
+        this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(c));
     }
-    updateRestoreTimeout() {
+    updateRestoreTimeout(c) {
         if (this._restoreAutomaticStateTimeout !== null) {
             clearTimeout(this._restoreAutomaticStateTimeout);
         }
         this._restoreAutomaticStateTimeout = utils_1.Utils.guardedTimeout(() => {
-            this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(models_1.CommandSource.Unknown, 'Automatic block restore timeout'));
+            this._restoreAutomatic(c);
         }, this._automaticBlockedUntil.getTime() - utils_1.Utils.nowMS() + 500, this);
     }
     toJSON() {

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

@@ -130,7 +130,7 @@ class OwnGoveeDevice {
             this.turnOff();
         }
         if (c.timeout > -1 && !dontBlock) {
-            this.blockAutomationHandler.disableAutomatic(c.timeout, models_1.CollisionSolving.overrideIfGreater);
+            this.blockAutomationHandler.disableAutomatic(new models_1.BlockAutomaticCommand(c, c.timeout));
         }
     }
     setActuator(c) {