hoffmation-base 3.4.9 → 3.6.0

package/lib/interfaces/baseDevices/iAcDevice.d.ts

@@ -1,11 +1,11 @@
 import { iAcSettings } from '../deviceSettings';
 import { iBaseDevice } from './iBaseDevice';
 import { AcMode } from '../../enums';
+import { AcSetStateCommand, AcWriteStateToDeviceCommand } from '../../command';
 /**
  * Interface for normal air-conditioning devices
  *
  * For devices with {@link DeviceCapability.ac} capability.
- * TODO: Migrate to new Command-Based System
  * TODO: Extend from iActuator
  */
 export interface iAcDevice extends iBaseDevice {
@@ -48,21 +48,31 @@ export interface iAcDevice extends iBaseDevice {
      * @param writeToDevice - Whether to write the new mode to the device
      */
     setDesiredMode(mode: AcMode, writeToDevice: boolean): void;
+    /**
+     * Performs a power write, applying any automatic block the command carries
+     * @param c - The command to execute
+     */
+    writeStateToDevice(c: AcWriteStateToDeviceCommand): void;
     /**
      * Turns the air-conditioning device on without changing the settings
+     * @param c - The command to execute
      */
-    turnOn(): void;
+    turnOn(c: AcWriteStateToDeviceCommand): void;
     /**
      * Turns the air-conditioning device off
+     * @param c - The command to execute
      */
-    turnOff(): void;
+    turnOff(c: AcWriteStateToDeviceCommand): void;
     /**
      * Calculates the desired mode based on the current settings and the room temperature
      * @returns The desired mode
      */
     calculateDesiredMode(): AcMode;
     /**
+     * Sets the state of the air-conditioning device.
      *
+     * Single entry point for every state change, so each one is recorded in the command log.
+     * @param c - The command to execute
      */
-    setState(desiredMode: AcMode, desiredTemperature: number | undefined, forceTime: number): void;
+    setAcState(c: AcSetStateCommand): void;
 }

package/lib/interfaces/baseDevices/iExcessEnergyConsumer.d.ts

@@ -1,5 +1,6 @@
 import { iBaseDevice } from './iBaseDevice';
 import { iExcessEnergyConsumerSettings } from '../settings';
+import { ExcessEnergyConsumerSetStateCommand } from '../../command';
 /**
  * This interface represents a device that can consume excess energy.
  *
@@ -25,13 +26,13 @@ export interface iExcessEnergyConsumer extends iBaseDevice {
      */
     isAvailableForExcessEnergy(): boolean;
     /**
-     * Turn on this device to consume excess energy
+     * Start or stop this device following an energy-manager decision.
+     *
+     * One entry point rather than separate turn-on/turn-off methods, so the desired state can
+     * only come from the command and cannot contradict the method that was called.
+     * @param c - The decision this results from, carrying the measurement it was based on
      */
-    turnOnForExcessEnergy(): void;
-    /**
-     * Turn off this device as we don't have enough excess energy to power it
-     */
-    turnOffDueToMissingEnergy(): void;
+    setExcessEnergyState(c: ExcessEnergyConsumerSetStateCommand): void;
     /**
      * Check if this device was activated by excess energy
      * @returns Whether this device was activated by excess energy

package/lib/interfaces/groups/iHeatGroup.d.ts

@@ -2,6 +2,8 @@ import { iBaseGroup } from './iBaseGroup';
 import { iAcDevice, iHeater, iHumidityCollector, iTemperatureCollector } from '../baseDevices';
 import { iTemperatureSettings } from '../settings';
 import { iHeatGroupSettings } from './iHeatGroupSettings';
+import { CommandSource } from '../../enums';
+import { iBaseCommand } from '../../command';
 /**
  *
  */
@@ -44,11 +46,10 @@ export interface iHeatGroup extends iBaseGroup {
     initialize(): void;
     /**
      * Sets all ACs to new desired Value
-     * TODO: Migrate to new Command System
      * @param newDesiredState - The new desired (on/off) state
-     * @param force - Whether this was a manual trigger, thus blocking automatic changes for 1 hour
+     * @param source - The event this results from, so the device command can be traced back to it
      */
-    setAc(newDesiredState: boolean, force: boolean): void;
+    setAc(newDesiredState: boolean, source: CommandSource | iBaseCommand): void;
     /**
      *
      */

package/lib/services/ac/ac-device.d.ts

@@ -2,6 +2,7 @@ import { AcSettings, RoomBaseDevice } from '../../devices';
 import { iAcDevice, iExcessEnergyConsumer, iTemporaryDisableAutomatic } from '../../interfaces';
 import { AcDeviceType, AcMode, DeviceType } from '../../enums';
 import { BlockAutomaticHandler } from '../blockAutomaticHandler';
+import { AcPerformAutomaticCheckCommand, AcSetStateCommand, AcWriteStateToDeviceCommand, ExcessEnergyConsumerSetStateCommand, RestoreTargetAutomaticValueCommand } from '../../command';
 import { ExcessEnergyConsumerSettings } from '../../settingsObjects';
 export declare abstract class AcDevice extends RoomBaseDevice implements iExcessEnergyConsumer, iAcDevice, iTemporaryDisableAutomatic {
     ip: string;
@@ -49,13 +50,22 @@ export declare abstract class AcDevice extends RoomBaseDevice implements iExcess
     abstract get on(): boolean;
     initializeRoomCbs(): void;
     /** @inheritDoc */
-    restoreTargetAutomaticValue(): void;
+    restoreTargetAutomaticValue(c: RestoreTargetAutomaticValueCommand): void;
     /** @inheritDoc */
     isAvailableForExcessEnergy(): boolean;
     /** @inheritDoc */
     calculateDesiredMode(): AcMode;
     abstract setDesiredMode(mode: AcMode, writeToDevice: boolean, temp?: number): void;
-    abstract turnOn(): void;
+    /**
+     * Performs a power write, applying any automatic block the command carries.
+     *
+     * Single place where a block from a write command is honoured, so callers never have to
+     * follow up with a separate disableAutomatic call. A block is not a device setting, so it
+     * belongs on a pure power write just as much as on a state change.
+     * @param c - The command to execute
+     */
+    writeStateToDevice(c: AcWriteStateToDeviceCommand): void;
+    abstract turnOn(c: AcWriteStateToDeviceCommand): void;
     /** @inheritDoc */
     onTemperaturChange(newTemperatur: number): void;
     /**
@@ -63,22 +73,44 @@ export declare abstract class AcDevice extends RoomBaseDevice implements iExcess
      */
     persist(): void;
     /** @inheritDoc */
-    turnOnForExcessEnergy(): void;
-    abstract turnOff(): void;
-    /** @inheritDoc */
-    turnOffDueToMissingEnergy(): void;
+    setExcessEnergyState(c: ExcessEnergyConsumerSetStateCommand): void;
+    abstract turnOff(c: AcWriteStateToDeviceCommand): void;
     /**
-     * Sets the state of the AC
-     * TODO: Migrate to new command system
-     * @param mode - The desired mode
-     * @param desiredTemp - The desired temperature (if unset it will be calculated)
-     * @param forceTime - The time in ms to force the AC to stay in this state (default 1h)
+     * Sets the state of the AC.
+     *
+     * Single entry point for every state change, so each one lands in the command log and
+     * the reason a unit switched can be reconstructed afterwards. Callers that represent an
+     * automatic decision pass no disableAutomaticCommand, so they do not block themselves.
+     * @param c - The command to execute
      */
-    setState(mode: AcMode, desiredTemp?: number, forceTime?: number): void;
+    setAcState(c: AcSetStateCommand): void;
     /** @inheritDoc */
     wasActivatedByExcessEnergy(): boolean;
-    protected automaticCheck(): void;
+    /**
+     * Re-evaluates what the state should be and applies it.
+     * @param c - The command asking for the re-evaluation; the resulting device command chains
+     * from it, so the log shows what triggered the change
+     */
+    protected automaticCheck(c: AcPerformAutomaticCheckCommand): void;
     private onRoomAnyMovement;
+    /**
+     * Keeps the unit off for as long as the room counts as occupied - renewed by every movement.
+     *
+     * Without a block, staying off depended on the five-minute interval check noticing that somebody
+     * is present, and coming back on depended on the last-leave callback arriving. The block replaces
+     * both with one timer: every movement pushes it out, and its expiry reverts to automatic by
+     * itself, so the room cools again shortly after it empties rather than at the next check.
+     *
+     * The duration is the room's own movementResetTimer - the same span that decides when the room
+     * counts as empty. Anything shorter would let the unit start up with somebody still sitting there;
+     * a separate constant would be a second answer to a question the room already answers.
+     *
+     * The collision strategy is deliberately left at its default (overrideIfGreater): a long press on
+     * the wall button sets a much longer block, and walking past the unit must not cut that short.
+     * @param c - The command the block chains from, so the log shows what triggered it
+     * @returns The block, or undefined when the device has no room to take the duration from
+     */
+    private buildMovementBlock;
     private onRoomLastLeave;
     /** @inheritDoc */
     toJSON(): Partial<AcDevice>;

package/lib/services/ac/ac-device.js

@@ -67,7 +67,7 @@ class AcDevice extends devices_1.RoomBaseDevice {
         this.deviceCapabilities.push(enums_1.DeviceCapability.ac);
         this.deviceCapabilities.push(enums_1.DeviceCapability.blockAutomatic);
         this.deviceCapabilities.push(enums_1.DeviceCapability.excessEnergyConsumer);
-        utils_1.Utils.guardedInterval(this.automaticCheck, 5 * 60 * 1000, this, false);
+        utils_1.Utils.guardedInterval(() => this.automaticCheck(new command_1.AcPerformAutomaticCheckCommand(enums_1.CommandSource.Automatic, 'Time interval check')), 5 * 60 * 1000, this, false);
         utils_1.Utils.guardedInterval(this.persist, 15 * 60 * 1000, this, true);
         this.blockAutomationHandler = new blockAutomaticHandler_1.BlockAutomaticHandler(this.restoreTargetAutomaticValue.bind(this), this.log.bind(this));
     }
@@ -100,16 +100,14 @@ class AcDevice extends devices_1.RoomBaseDevice {
         }
         utils_1.Utils.guardedFunction(() => {
             var _a, _b;
-            // TODO: Maybe change to any Movement
             (_a = this.room.PraesenzGroup) === null || _a === void 0 ? void 0 : _a.addAnyMovementCallback(this.onRoomAnyMovement.bind(this));
             (_b = this.room.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.addLastLeftCallback(this.onRoomLastLeave.bind(this));
             this._movementCallbackAdded = true;
         }, this);
     }
     /** @inheritDoc */
-    restoreTargetAutomaticValue() {
-        this.log(enums_1.LogLevel.Debug, 'Restore Target Automatic value');
-        this.automaticCheck();
+    restoreTargetAutomaticValue(c) {
+        this.automaticCheck(new command_1.AcPerformAutomaticCheckCommand(c, 'Restore automatic value'));
     }
     /** @inheritDoc */
     isAvailableForExcessEnergy() {
@@ -222,6 +220,24 @@ class AcDevice extends devices_1.RoomBaseDevice {
         }
         return desiredMode;
     }
+    /**
+     * Performs a power write, applying any automatic block the command carries.
+     *
+     * Single place where a block from a write command is honoured, so callers never have to
+     * follow up with a separate disableAutomatic call. A block is not a device setting, so it
+     * belongs on a pure power write just as much as on a state change.
+     * @param c - The command to execute
+     */
+    writeStateToDevice(c) {
+        if (c.disableAutomaticCommand) {
+            this.blockAutomationHandler.disableAutomatic(c.disableAutomaticCommand);
+        }
+        if (c.on) {
+            this.turnOn(c);
+            return;
+        }
+        this.turnOff(c);
+    }
     /** @inheritDoc */
     onTemperaturChange(newTemperatur) {
         this.roomTemperatur = newTemperatur;
@@ -237,47 +253,67 @@ class AcDevice extends devices_1.RoomBaseDevice {
         (_a = dbo_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.persistAC(this);
     }
     /** @inheritDoc */
-    turnOnForExcessEnergy() {
+    setExcessEnergyState(c) {
         var _a, _b;
+        if (!c.on) {
+            this.setAcState(new command_1.AcSetStateCommand(c, enums_1.AcMode.Off, undefined, 'Missing excess energy'));
+            return;
+        }
         if (this.blockAutomationHandler.automaticBlockActive) {
             return;
         }
-        this._activatedByExcessEnergy = true;
         const desiredMode = this.calculateDesiredMode();
+        if (desiredMode === enums_1.AcMode.Off) {
+            // isAvailableForExcessEnergy does not cover manualDisabled or an ac-blocking energy
+            // manager, so the device can still say it wants to stay off. Leave it alone rather than
+            // forcing it on, and do not claim it was activated by excess energy.
+            this.logCommand(c, 'Excess energy offered, but the device wants to stay off', enums_1.LogDebugType.SkipUnchangedActuatorCommand);
+            return;
+        }
         if (desiredMode === enums_1.AcMode.Cooling &&
             this.settings.noCoolingOnMovement &&
             ((_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent(true))) {
             return;
         }
-        this.setDesiredMode(this.calculateDesiredMode(), false);
-        this.turnOn();
-    }
-    /** @inheritDoc */
-    turnOffDueToMissingEnergy() {
-        this.turnOff();
+        this._activatedByExcessEnergy = true;
+        this.setAcState(new command_1.AcSetStateCommand(c, desiredMode, undefined, 'Excess energy available'));
     }
     /**
-     * Sets the state of the AC
-     * TODO: Migrate to new command system
-     * @param mode - The desired mode
-     * @param desiredTemp - The desired temperature (if unset it will be calculated)
-     * @param forceTime - The time in ms to force the AC to stay in this state (default 1h)
+     * Sets the state of the AC.
+     *
+     * Single entry point for every state change, so each one lands in the command log and
+     * the reason a unit switched can be reconstructed afterwards. Callers that represent an
+     * automatic decision pass no disableAutomaticCommand, so they do not block themselves.
+     * @param c - The command to execute
      */
-    setState(mode, desiredTemp, forceTime = 60 * 60 * 1000) {
-        this.blockAutomationHandler.disableAutomatic(new command_1.BlockAutomaticCommand(enums_1.CommandSource.Unknown, forceTime));
+    setAcState(c) {
+        var _a;
+        this.logCommand(c);
+        if (c.disableAutomaticCommand) {
+            this.blockAutomationHandler.disableAutomatic(c.disableAutomaticCommand);
+        }
+        // An unset mode means "just switch it on" - which mode that is depends on season and
+        // settings, so the device resolves it rather than the caller.
+        const mode = (_a = c.mode) !== null && _a !== void 0 ? _a : (this.heatingAllowed ? enums_1.AcMode.Heating : enums_1.AcMode.Cooling);
         this._mode = mode;
-        if (mode == enums_1.AcMode.Off) {
-            this.turnOff();
-            return;
+        // The write command chains back to this one, so the device log shows both the
+        // intent and the actual power write, mirroring the actuator path.
+        const writeCommand = new command_1.AcWriteStateToDeviceCommand(c, c.on);
+        if (c.on) {
+            this.setDesiredMode(mode, false, c.desiredTemperature);
         }
-        this.setDesiredMode(mode, false, desiredTemp);
-        this.turnOn();
+        this.writeStateToDevice(writeCommand);
     }
     /** @inheritDoc */
     wasActivatedByExcessEnergy() {
         return this._activatedByExcessEnergy;
     }
-    automaticCheck() {
+    /**
+     * Re-evaluates what the state should be and applies it.
+     * @param c - The command asking for the re-evaluation; the resulting device command chains
+     * from it, so the log shows what triggered the change
+     */
+    automaticCheck(c) {
         var _a, _b;
         if (this.blockAutomationHandler.automaticBlockActive) {
             // We aren't allowed to turn on or off anyway --> exit
@@ -288,29 +324,57 @@ class AcDevice extends devices_1.RoomBaseDevice {
             // Device already in desired state --> do nothing
             return;
         }
+        // Kept ahead of the branch as before: turning off still reports the mode we would
+        // otherwise have wanted, which setDesiredInfo sends alongside the power state.
         this.setDesiredMode(desiredMode, false);
         if (desiredMode == enums_1.AcMode.Off ||
             (desiredMode === enums_1.AcMode.Cooling &&
                 this.settings.noCoolingOnMovement &&
                 ((_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.PraesenzGroup) === null || _b === void 0 ? void 0 : _b.anyPresent(true)))) {
-            this.turnOff();
+            this.setAcState(new command_1.AcSetStateCommand(c, enums_1.AcMode.Off, undefined, 'No cooling wanted'));
             return;
         }
-        this.turnOn();
+        this.setAcState(new command_1.AcSetStateCommand(c, desiredMode, undefined, 'Desired mode reached'));
     }
-    onRoomAnyMovement(_action) {
+    onRoomAnyMovement(action) {
         if (!this.settings.noCoolingOnMovement || !this.on || this.mode === enums_1.AcMode.Heating) {
             return;
         }
-        this.log(enums_1.LogLevel.Info, 'Something moved in the room. Turning off AC');
-        this.turnOff();
+        this.setAcState(new command_1.AcSetStateCommand(action, enums_1.AcMode.Off, undefined, 'Something moved in the room and noCoolingOnMovement is set.', this.buildMovementBlock(action)));
+    }
+    /**
+     * Keeps the unit off for as long as the room counts as occupied - renewed by every movement.
+     *
+     * Without a block, staying off depended on the five-minute interval check noticing that somebody
+     * is present, and coming back on depended on the last-leave callback arriving. The block replaces
+     * both with one timer: every movement pushes it out, and its expiry reverts to automatic by
+     * itself, so the room cools again shortly after it empties rather than at the next check.
+     *
+     * The duration is the room's own movementResetTimer - the same span that decides when the room
+     * counts as empty. Anything shorter would let the unit start up with somebody still sitting there;
+     * a separate constant would be a second answer to a question the room already answers.
+     *
+     * The collision strategy is deliberately left at its default (overrideIfGreater): a long press on
+     * the wall button sets a much longer block, and walking past the unit must not cut that short.
+     * @param c - The command the block chains from, so the log shows what triggered it
+     * @returns The block, or undefined when the device has no room to take the duration from
+     */
+    buildMovementBlock(c) {
+        var _a, _b;
+        const occupiedForSeconds = (_b = (_a = this.room) === null || _a === void 0 ? void 0 : _a.settings) === null || _b === void 0 ? void 0 : _b.movementResetTimer;
+        // No room means no answer to "how long does this count as occupied". Switching off without a
+        // block is what happened before this existed, and it is the honest fallback - a made-up
+        // duration would block the automatic for a span nothing chose.
+        if (occupiedForSeconds === undefined || occupiedForSeconds <= 0) {
+            return undefined;
+        }
+        return new command_1.BlockAutomaticCommand(c, occupiedForSeconds * 1000, 'noCoolingOnMovement', undefined, true);
     }
     onRoomLastLeave(action) {
         if (!this.settings.noCoolingOnMovement) {
             return;
         }
-        this.log(enums_1.LogLevel.Info, `Last person left the room (${action.reasonTrace}). Checking if we should turn on AC`);
-        this.restoreTargetAutomaticValue();
+        this.restoreTargetAutomaticValue(new command_1.RestoreTargetAutomaticValueCommand(action, 'Last person left the room, whilst noCoolingOnMovement is set'));
     }
     /** @inheritDoc */
     toJSON() {

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

@@ -1,5 +1,6 @@
 import { DaikinAC, DaikinManager } from 'daikin-controller';
 import { AcDevice } from './ac-device';
+import { AcWriteStateToDeviceCommand } from '../../command';
 export declare class DaikinService {
     private static _ownDevices;
     private static _daikinManager;
@@ -11,7 +12,7 @@ export declare class DaikinService {
     }): void;
     static getDevice(name: string): DaikinAC | undefined;
     static initialize(): Promise<void>;
-    static setAll(on: boolean, force?: boolean): void;
+    static setAll(c: AcWriteStateToDeviceCommand, force?: boolean): void;
     static reconnect(name: string, ip: string, mac?: string): Promise<DaikinAC | undefined>;
     private static reconstructDaikinAc;
     private static initializeDevice;

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

@@ -38,14 +38,14 @@ class DaikinService {
         Telegram_1.TelegramService.addMessageCallback(new Telegram_1.TelegramMessageCallback('AcOn', /\/ac_on/, async (m) => {
             if (m.from === undefined)
                 return false;
-            DaikinService.setAll(true);
+            DaikinService.setAll(new command_1.AcWriteStateToDeviceCommand(enums_1.CommandSource.Manual, true, `Telegram /ac_on by ${m.from.id}`));
             Telegram_1.TelegramService.sendMessage([m.chat.id], 'Command executed');
             return true;
         }, "Turns all Ac's on without changing any settings"));
         Telegram_1.TelegramService.addMessageCallback(new Telegram_1.TelegramMessageCallback('AcOff', /\/ac_off/, async (m) => {
             if (m.from === undefined)
                 return false;
-            DaikinService.setAll(false, true);
+            DaikinService.setAll(new command_1.AcWriteStateToDeviceCommand(enums_1.CommandSource.Manual, false, `Telegram /ac_off by ${m.from.id}`), true);
             Telegram_1.TelegramService.sendMessage([m.chat.id], 'Command executed');
             return true;
         }, "Turns all Ac's off without changing any settings"));
@@ -68,22 +68,17 @@ class DaikinService {
             });
         });
     }
-    // TODO: Migrate to new command system
-    static setAll(on, force = false) {
+    static setAll(c, force = false) {
         if (!this.isInitialized) {
             return;
         }
         for (const deviceName in this._ownDevices) {
             const dev = this._ownDevices[deviceName];
-            if (on) {
-                dev.turnOn();
-            }
-            else {
-                dev.turnOff();
-            }
-            if (force) {
-                dev.blockAutomationHandler.disableAutomatic(new command_1.BlockAutomaticCommand(enums_1.CommandSource.Unknown, 180 * 60 * 1000));
-            }
+            // Contract of this method is to switch power without touching any settings, so it
+            // addresses the write layer rather than setAcState, which would resolve and apply a mode.
+            // The block is not a setting, so it travels in the command like everywhere else.
+            c.disableAutomaticCommand = force ? new command_1.BlockAutomaticCommand(c, 180 * 60 * 1000) : undefined;
+            dev.writeStateToDevice(c);
         }
     }
     static async reconnect(name, ip, mac) {

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

@@ -1,4 +1,5 @@
 import { AcDevice } from './ac-device';
+import { AcPerformAutomaticCheckCommand, AcWriteStateToDeviceCommand } from '../../command';
 import { DaikinAC } from 'daikin-controller';
 import { AcMode, DeviceType } from '../../enums';
 export declare class OwnDaikinDevice extends AcDevice {
@@ -29,10 +30,10 @@ export declare class OwnDaikinDevice extends AcDevice {
     /** @inheritDoc */
     setDesiredMode(mode: AcMode, writeToDevice?: boolean, desiredTemp?: number): void;
     /** @inheritDoc */
-    turnOn(): void;
+    turnOn(c: AcWriteStateToDeviceCommand): void;
     /** @inheritDoc */
-    turnOff(): void;
-    protected automaticCheck(): void;
+    turnOff(c: AcWriteStateToDeviceCommand): void;
+    protected automaticCheck(c: AcPerformAutomaticCheckCommand): void;
     private setDesiredInfo;
     private updateInfo;
     /**

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

@@ -77,23 +77,23 @@ class OwnDaikinDevice extends ac_device_1.AcDevice {
         }
     }
     /** @inheritDoc */
-    turnOn() {
-        this.log(enums_1.LogLevel.Info, 'Turning on');
+    turnOn(c) {
+        this.logCommand(c);
         this.desiredState = daikin_controller_1.Power.ON;
         this.setDesiredInfo();
     }
     /** @inheritDoc */
-    turnOff() {
-        this.log(enums_1.LogLevel.Info, 'Turning off');
+    turnOff(c) {
+        this.logCommand(c);
         this._activatedByExcessEnergy = false;
         this.desiredState = daikin_controller_1.Power.OFF;
         this._mode = enums_1.AcMode.Off;
         this.setDesiredInfo();
     }
-    automaticCheck() {
+    automaticCheck(c) {
         // First Load Device Info, then perform check
         this.updateInfo().then((_on) => {
-            super.automaticCheck();
+            super.automaticCheck(c);
         });
     }
     setDesiredInfo(retry = false, forceTemp) {