hoffmation-base 3.0.0-alpha.9 → 3.0.0-alpha.90

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

@@ -7,13 +7,11 @@ const room_service_1 = require("../room-service");
 const log_service_1 = require("../log-service");
 const ac_1 = require("../ac");
 const DeviceCapability_1 = require("../../devices/DeviceCapability");
-const settings_service_1 = require("../settings-service");
-const config_1 = require("../../config");
 class API {
     /**
      * Endpoint to end a scene manually (or early if it has automatic turn off)
-     * @param {string} deviceId
-     * @returns {Error | null}
+     * @param deviceId - The id of the scene to end
+     * @returns In case it failed the Error containing the reason
      */
     static endScene(deviceId) {
         const d = this.getDevice(deviceId);
@@ -23,14 +21,14 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.scene)) {
             return new Error(`Device with ID ${deviceId} is no scene`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to end this.`);
+        d.log(models_1.LogLevel.Info, 'API Call to end this.');
         d.endScene();
         return null;
     }
     /**
      * Gets the instance of an Ac Device identified by id
-     * @param {string} id
-     * @returns {OwnDaikinDevice | undefined}
+     * @param id - The device id of the AC
+     * @returns The instance of the AC Device or undefined if not found
      */
     static getAc(id) {
         const result = this.getDevice(id);
@@ -39,17 +37,20 @@ class API {
         }
         return result;
     }
+    // TODO: Missing Comment
     static getDevices() {
         // console.log(Util.inspect(Devices.alLDevices, false, 5));
         return devices_1.Devices.alLDevices;
     }
-    static getDevice(id) {
+    // TODO: Missing Comment
+    static getDevice(id, warnIfNotFound = true) {
         const d = devices_1.Devices.alLDevices[id];
-        if (d === undefined) {
+        if (d === undefined && warnIfNotFound) {
             log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Api.getDevice() --> "${id}" not found`);
         }
-        return devices_1.Devices.alLDevices[id];
+        return d;
     }
+    // TODO: Missing Comment
     static getGroup(id) {
         const g = room_service_1.RoomService.Groups.get(id);
         if (g === undefined) {
@@ -57,23 +58,27 @@ 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();
     }
     /**
      * Turns on/off one AC identified by it's id
-     * @param id The id of the device, if wrong false will be returned
-     * @param {boolean} desiredState
-     * @param {AcMode} desiredMode
-     * @param desiredTemperature
-     * @param forceTime The time in ms this should not change before automatic change is allowed again
+     * @param id - The id of the device, if wrong false will be returned
+     * @param desiredState - The desired state for the AC
+     * @param desiredMode - The desired mode for the AC
+     * @param desiredTemperature - The desired temperature for the AC in Celsius
+     * @param forceTime - The time in ms this should not change before automatic change is allowed again
+     * @returns True if the AC was found and the state was changed
      */
     static setAc(id, desiredState, desiredMode, desiredTemperature, forceTime = 60 * 60 * 1000) {
         const d = this.getAc(id);
@@ -90,7 +95,7 @@ class API {
                 desiredMode = ac_1.AcMode.Off;
             }
             else {
-                desiredMode = settings_service_1.SettingsService.heatMode == config_1.HeatingMode.Winter ? ac_1.AcMode.Heating : ac_1.AcMode.Cooling;
+                desiredMode = d.heatingAllowed ? ac_1.AcMode.Heating : ac_1.AcMode.Cooling;
             }
         }
         d.log(models_1.LogLevel.Info, `API Call to set AC to ${desiredState} with mode ${desiredMode} for ${forceTime}ms`);
@@ -99,7 +104,7 @@ class API {
     }
     /**
      * Turns on/off all AC´s in the home
-     * @param {boolean} desiredState
+     * @param desiredState - The desired state for all AC´s
      */
     static setAllAc(desiredState) {
         ac_1.DaikinService.setAll(desiredState, true);
@@ -107,12 +112,23 @@ class API {
     }
     /**
      * Changes the status of a given Lamp
-     * @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
+     * @param deviceId - The device Id of the lamp
+     * @param state - The desired new state
+     * @param timeout - Desired time after which this should be reverted to normal state
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.lampSetLight} instead
+     * TODO: Remove deprecated API method
      */
     static setLamp(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.lampSetLight(deviceId, new models_1.LampSetLightCommand(models_1.CommandSource.API, state, '', new models_1.BlockAutomaticCommand(models_1.CommandSource.API, timeout)));
+    }
+    /**
+     * Changes the status of a given Lamp
+     * @param deviceId - The device Id of the lamp
+     * @param c - The command(stack) to perform on the lamp
+     * @returns 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 +136,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
-     * @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
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - Desired time after which this should be reverted to automatic state
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.actuatorSetState} instead
+     * TODO: Remove deprecated API method
      */
     static setActuator(deviceId, state, timeout = 60 * 60 * 1000) {
+        return this.actuatorSetState(deviceId, new models_1.ActuatorSetStateCommand(models_1.CommandSource.API, state, '', new models_1.BlockAutomaticCommand(models_1.CommandSource.API, timeout)));
+    }
+    /**
+     * Changes the status of a given actuator
+     * @param deviceId - The device Id of the actuator
+     * @param c - The command(stack) to perform on the actuator
+     * @returns 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,20 +166,31 @@ 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
-     * @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
-     * @param brightness The desired brightness
-     * @param transitionTime The transition time during turnOn/turnOff
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * Changes the status of the given dimmer
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - A chosen Timeout after which the light should be reset
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.dimmerSetLight} instead
+     * TODO: Remove deprecated API method
      */
     static setDimmer(deviceId, state, timeout, brightness, transitionTime) {
+        return this.dimmerSetLight(deviceId, new models_1.DimmerSetLightCommand(models_1.CommandSource.API, state, '', new models_1.BlockAutomaticCommand(models_1.CommandSource.API, timeout), brightness, transitionTime));
+    }
+    /**
+     * Changes the status of the given dimmer
+     * @param deviceId - The device Id of the dimmable device.
+     * @param command - The command(stack) to perform on the dimmer
+     * @returns 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,41 +198,64 @@ 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
-     * @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
-     * @param brightness The desired brightness
-     * @param transitionTime The transition time during turnOn/turnOff
-     * @param {string} color The desired color in 6 digit hex Code
-     * @param {number} colorTemp The desired color Temperature (0 = more White)
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * Changes the status of a given led-device
+     * @param deviceId - The device Id of the actuator
+     * @param state - The desired new state
+     * @param timeout - A chosen Timeout after which the light should be reset
+     * @param brightness - The desired brightness
+     * @param transitionTime - The transition time during turnOn/turnOff
+     * @param color - The desired color in 6 digit hex Code
+     * @param colorTemp - The desired color Temperature (0 = more White)
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.ledSetLight} instead
+     * TODO: Remove deprecated API method
      */
     static setLedLamp(deviceId, state, timeout, brightness, transitionTime, color, colorTemp) {
+        return this.ledSetLight(deviceId, new models_1.LedSetLightCommand(models_1.CommandSource.API, state, '', new models_1.BlockAutomaticCommand(models_1.CommandSource.API, timeout), brightness, transitionTime, color, colorTemp));
+    }
+    /**
+     * Changes the status of a given led-device
+     * @param deviceId - The device Id of the LED-Device
+     * @param command - The command(stack) to perform on the led-device
+     * @returns In case it failed the Error containing the reason
+     */
+    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
-     * @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
+     * @param deviceId - The device Id of the shutter
+     * @param level - The desired new level (0 being open, 100 being closed)
+     * @returns Error if there is no shutter with the given id
+     * @deprecated Use {@link API.shutterSetLevel} instead
+     * TODO: Remove deprecated API method
      */
     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 deviceId - The device Id of the shutter
+     * @param command - The command(stack) to perform on the shutter
+     * @returns 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) {
@@ -226,9 +288,9 @@ class API {
     }
     /**
      * Starts a specified scene
-     * @param {string} deviceId The targeted scene
-     * @param {number} turnOffTimeout If provided the time in ms after which the scene should end automatically
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The targeted scene
+     * @param turnOffTimeout - If provided the time in ms after which the scene should end automatically
+     * @returns In case it failed the Error containing the reason
      */
     static startScene(deviceId, turnOffTimeout) {
         const d = this.getDevice(deviceId);
@@ -238,7 +300,7 @@ class API {
         if (!d.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.scene)) {
             return new Error(`Device with ID ${deviceId} is no scene`);
         }
-        d.log(models_1.LogLevel.Info, `API Call to start this.`);
+        d.log(models_1.LogLevel.Info, 'API Call to start this.');
         d.startScene(turnOffTimeout);
         return null;
     }
@@ -251,20 +313,20 @@ class API {
             return new Error(`Device with ID ${deviceId} is no Garage Door Opener`);
         }
         if (open) {
-            d.log(models_1.LogLevel.Info, `API Call to open Garage Door`);
+            d.log(models_1.LogLevel.Info, 'API Call to open Garage Door');
             d.open();
         }
         else {
-            d.log(models_1.LogLevel.Info, `API Call to close Garage Door`);
+            d.log(models_1.LogLevel.Info, 'API Call to close Garage Door');
             d.close();
         }
         return null;
     }
     /**
      * Changes the settings of a given device
-     * @param {string} deviceId The id of the device to change the settings
-     * @param settings A partial settings object containing the wanted settings properties
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The id of the device to change the settings
+     * @param settings - A partial settings object containing the wanted settings properties
+     * @returns In case it failed the Error containing the reason
      */
     static setDeviceSettings(deviceId, settings) {
         const d = this.getDevice(deviceId);
@@ -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) {
@@ -294,9 +357,9 @@ class API {
     }
     /**
      * Changes the settings of a given room
-     * @param {string} roomName The id of the Room to change the settings
-     * @param settings A partial settings object containing the wanted settings properties
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param roomName - The id of the Room to change the settings
+     * @param settings - A partial settings object containing the wanted settings properties
+     * @returns In case it failed the Error containing the reason
      */
     static setRoomSettings(roomName, settings) {
         const r = this.getRoom(roomName);
@@ -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,25 +382,38 @@ 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`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'API Call to persist all device settings');
         for (const device of Object.values(devices_1.Devices.alLDevices)) {
             (_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`);
+        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)) {
             device.loadDeviceSettings();
         }
     }
     /**
      * Lifts a previously started Block of automatic
-     * @param {string} deviceId The target device
-     * @returns {Error | null} In case it failed the Error containing the reason
+     * @param deviceId - The target device
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.blockAutomaticLiftAutomaticBlock} instead
+     * TODO: V4 Remove deprecated API method
      */
     static liftAutomaticBlock(deviceId) {
+        return this.blockAutomaticLiftAutomaticBlock(deviceId, new models_1.BlockAutomaticLiftBlockCommand(models_1.CommandSource.API));
+    }
+    /**
+     * Lifts a previously started Block of automatic
+     * @param deviceId - The target device
+     * @param command - The command to lift the automatic block
+     * @returns 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
-     * @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
+     * @param deviceId - The target device
+     * @param duration - The duration in ms for which the device should remain in current state
+     * @param onCollision - The desired Collision Solving strategy, in case the automatic being blocked already
+     * @returns In case it failed the Error containing the reason
+     * @deprecated Use {@link API.blockAutomaticSetBlock} instead
+     * TODO: Remove deprecated API method
      */
     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 deviceId - The target device
+     * @param command - The command to block the automatic
+     * @returns 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,17 +1,22 @@
-/// <reference types="node" />
-import { CollisionSolving, RestoreTargetAutomaticValueCommand } from '../../models';
+import { BlockAutomaticCommand, BlockAutomaticLiftBlockCommand, BlockAutomaticUntilCommand, LogLevel, RestoreTargetAutomaticValueCommand } from '../../models';
+import { LogDebugType } from './log-service';
+/**
+ * This class is responsible for blocking automatic actions for a specific duration.
+ * It also provides the possibility to lift the block before the duration is over {@link BlockAutomaticLiftBlockCommand}.
+ */
 export declare class BlockAutomaticHandler {
+    private readonly _logger;
     private readonly _restoreAutomatic;
-    constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void);
     private _automaticBlockedUntil;
+    private _restoreAutomaticStateTimeout;
+    constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void, _logger: (level: LogLevel, message: string, logDebugType?: LogDebugType) => 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(): void;
+    disableAutomatic(c: BlockAutomaticCommand): void;
+    disableAutomaticUntil(c: BlockAutomaticUntilCommand): void;
+    liftAutomaticBlock(c: BlockAutomaticLiftBlockCommand): void;
+    private removeRestoreTimeout;
     private updateRestoreTimeout;
     toJSON(): Partial<BlockAutomaticHandler>;
 }

package/lib/server/services/blockAutomaticHandler.js

@@ -7,8 +7,13 @@ exports.BlockAutomaticHandler = void 0;
 const models_1 = require("../../models");
 const utils_1 = require("./utils");
 const lodash_1 = __importDefault(require("lodash"));
+/**
+ * This class is responsible for blocking automatic actions for a specific duration.
+ * It also provides the possibility to lift the block before the duration is over {@link BlockAutomaticLiftBlockCommand}.
+ */
 class BlockAutomaticHandler {
-    constructor(restoreAutomaticCb) {
+    constructor(restoreAutomaticCb, _logger) {
+        this._logger = _logger;
         this._automaticBlockedUntil = new Date(0);
         this._restoreAutomaticStateTimeout = null;
         this._restoreAutomatic = restoreAutomaticCb;
@@ -18,39 +23,53 @@ 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, c.revertToAutomaticAtBlockLift));
     }
-    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)) {
+            this._logger(models_1.LogLevel.Info, `Block already active until "${this.automaticBlockedUntil.toLocaleTimeString('de-DE')}" --> ignoring: ${c.logMessage}`);
             return;
         }
-        this.automaticBlockedUntil = targetDate;
+        this._logger(models_1.LogLevel.Info, c.logMessage);
+        this.automaticBlockedUntil = c.targetDate;
+        if (c.revertToAutomaticAtBlockLift) {
+            const revertCommand = new models_1.RestoreTargetAutomaticValueCommand(c, 'Restore to automatic state after block.');
+            revertCommand.overrideCommandSource = models_1.CommandSource.Automatic;
+            this.updateRestoreTimeout(revertCommand);
+        }
+        else {
+            this.removeRestoreTimeout();
+        }
     }
-    liftAutomaticBlock() {
+    liftAutomaticBlock(c) {
+        this.removeRestoreTimeout();
         this.automaticBlockedUntil = new Date(0);
+        if (c.revertToAutomatic) {
+            this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(c));
+        }
     }
-    updateRestoreTimeout() {
+    removeRestoreTimeout() {
         if (this._restoreAutomaticStateTimeout !== null) {
             clearTimeout(this._restoreAutomaticStateTimeout);
+            this._restoreAutomaticStateTimeout = null;
         }
+    }
+    updateRestoreTimeout(c) {
+        this.removeRestoreTimeout();
         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() {
-        return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, ['_restoreAutomatic']));
+        return utils_1.Utils.jsonFilter(lodash_1.default.omit(this, ['_restoreAutomatic', '_logger']));
     }
 }
 exports.BlockAutomaticHandler = BlockAutomaticHandler;

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

@@ -1,2 +1,3 @@
 export * from './muell-tonne';
 export * from './müll-service';
+export { NameDatePair } from './name-date-pair';

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

@@ -14,5 +14,8 @@ 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 });
+exports.NameDatePair = void 0;
 __exportStar(require("./muell-tonne"), exports);
 __exportStar(require("./m\u00FCll-service"), exports);
+var name_date_pair_1 = require("./name-date-pair");
+Object.defineProperty(exports, "NameDatePair", { enumerable: true, get: function () { return name_date_pair_1.NameDatePair; } });

package/lib/server/services/calendar/muell-tonne.d.ts

@@ -2,8 +2,18 @@ import { iSpeaker } from '../../devices';
 export declare class MuellTonne {
     name: string;
     ownSpeaker?: iSpeaker | undefined;
-    static oneDay: number;
+    /**
+     * The duration of a signle day in milliseconds (used for date calculations)
+     */
+    private static readonly oneDay;
+    /**
+     * The next date this bin will be emptied
+     */
     nextDate: Date | undefined;
+    /**
+     * All dates this bin will be emptied
+     * After a date has passed it will be removed
+     */
     dates: Date[];
     constructor(name: string, ownSpeaker?: iSpeaker | undefined);
     sortDates(): void;

package/lib/server/services/calendar/muell-tonne.js

@@ -8,7 +8,14 @@ class MuellTonne {
     constructor(name, ownSpeaker) {
         this.name = name;
         this.ownSpeaker = ownSpeaker;
+        /**
+         * The next date this bin will be emptied
+         */
         this.nextDate = undefined;
+        /**
+         * All dates this bin will be emptied
+         * After a date has passed it will be removed
+         */
         this.dates = [];
     }
     sortDates() {
@@ -65,4 +72,7 @@ class MuellTonne {
     }
 }
 exports.MuellTonne = MuellTonne;
+/**
+ * The duration of a signle day in milliseconds (used for date calculations)
+ */
 MuellTonne.oneDay = 1000 * 60 * 60 * 24;