hoffmation-base 3.5.0 → 3.6.1

package/lib/devices/groups/heatGroup.js

@@ -149,12 +149,22 @@ class HeatGroup extends base_group_1.BaseGroup {
         const devs = this.getOwnAcDevices();
         this.log(enums_1.LogLevel.Debug, `set ${devs.length} Ac's to new State: ${newDesiredState}`);
         for (const dev of devs) {
-            dev.setAcState(new command_1.AcSetStateCommand(source, 
+            const command = new command_1.AcSetStateCommand(source, 
             // Undefined mode means "just switch it on"; the device resolves which mode that is.
-            newDesiredState ? undefined : enums_1.AcMode.Off, undefined, 'HeatGroup setAc', 
-            // The block travels inside the command so setAcState applies it centrally. As
-            // before, only switching off pins the automatic.
-            newDesiredState ? undefined : new command_1.BlockAutomaticCommand(source, 60 * 60 * 1000)));
+            newDesiredState ? undefined : enums_1.AcMode.Off, undefined, 'HeatGroup setAc');
+            // As before, only switching off pins the automatic - and the block travels inside the command
+            // so setAcState applies it centrally.
+            //
+            // The duration now comes from the device's own settings, built the way every other device
+            // builds its block (see ShutterUtils.setLevel). It used to be a hard-coded hour here, which
+            // is exactly what the configured default resolves to - so nothing changes today; what changes
+            // is that a single unit can be given a shorter block without touching group code. Building it
+            // from the command rather than from `source` also puts the block into the reason chain, so the
+            // log says which switch-off set it.
+            if (!newDesiredState) {
+                command.disableAutomaticCommand = dev.settings.buildBlockAutomaticCommand(command);
+            }
+            dev.setAcState(command);
         }
     }
     deleteAutomaticPoint(name) {

package/lib/devices/sharedFunctions/shutterUtils.js

@@ -62,16 +62,21 @@ class ShutterUtils {
         }
         device.logCommand(c);
         if (device.window !== undefined) {
+            // Only a manual command deserves an alert, because only then is someone waiting for a shutter
+            // that will not move. The automatic run meets an open window every evening, and an Alert is
+            // what reaches Telegram - a nightly push for an expected skip. Info keeps the decision
+            // reconstructable without waking anybody.
+            const warningLevel = c.isManual ? enums_1.LogLevel.Alert : enums_1.LogLevel.Info;
             if (device.window.griffeInPosition(enums_1.WindowPosition.open) > 0 && pPosition < 100) {
                 if (!c.skipOpenWarning) {
-                    device.log(enums_1.LogLevel.Alert, 'Not closing the shutter, as the window is open!');
+                    device.log(warningLevel, 'Not closing the shutter, as the window is open!');
                 }
                 return;
             }
             if (device.window.griffeInPosition(enums_1.WindowPosition.tilted) > 0 && pPosition < 50) {
                 pPosition = 50;
                 if (!c.skipOpenWarning) {
-                    device.log(enums_1.LogLevel.Alert, 'Not closing the shutter, as the window is half open!');
+                    device.log(warningLevel, 'Not closing the shutter, as the window is half open!');
                 }
             }
         }

package/lib/interfaces/iBlockAutomaticHandler.d.ts

@@ -11,6 +11,10 @@ export interface iBlockAutomaticHandler {
      *
      */
     readonly automaticBlockActive: boolean;
+    /**
+     * Whether the active block was set by a person (Manual, API or Force) rather than by a rule.
+     */
+    readonly automaticBlockedByUser: boolean;
     /**
      *
      */

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

@@ -93,6 +93,24 @@ export declare abstract class AcDevice extends RoomBaseDevice implements iExcess
      */
     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

@@ -100,7 +100,6 @@ 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;
@@ -341,7 +340,46 @@ class AcDevice extends devices_1.RoomBaseDevice {
         if (!this.settings.noCoolingOnMovement || !this.on || this.mode === enums_1.AcMode.Heating) {
             return;
         }
-        this.setAcState(new command_1.AcSetStateCommand(action, enums_1.AcMode.Off, undefined, 'Something moved in the room and noCoolingOnMovement is set.'));
+        // Somebody asked for this unit to run and pinned it - a configured rule does not overrule that.
+        // This is the case the report was about: switching the AC on from the phone pins it for an hour,
+        // the next movement a minute later switched it off anyway, and the pin then kept the automatic
+        // from ever switching it back on. The unit stayed off for the full hour.
+        //
+        // Only a person's pin counts. The block this path sets itself is an automatic one, so a later
+        // movement can still renew it.
+        if (this.blockAutomationHandler.automaticBlockedByUser) {
+            this.log(enums_1.LogLevel.Debug, 'Movement detected, but the AC was pinned by hand - leaving it alone.');
+            return;
+        }
+        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) {

package/lib/services/blockAutomaticHandler.d.ts

@@ -9,11 +9,22 @@ export declare class BlockAutomaticHandler implements iBlockAutomaticHandler {
     private readonly _logger;
     private readonly _restoreAutomatic;
     private _automaticBlockedUntil;
+    private _blockSetByUser;
     private _restoreAutomaticStateTimeout;
     constructor(restoreAutomaticCb: (c: RestoreTargetAutomaticValueCommand) => void, _logger: (level: LogLevel, message: string, logDebugType?: LogDebugType) => void);
     get automaticBlockedUntil(): Date;
     private set automaticBlockedUntil(value);
     get automaticBlockActive(): boolean;
+    /**
+     * Whether the active block was set by a person rather than by another rule.
+     *
+     * The expiry date alone cannot answer that, and a rule that has to decide whether it may overrule
+     * the current state needs to: at the end of the day the user's choice outranks a configured
+     * automatism. Manual, API and Force all count - they are the same decision reaching the house
+     * through different doors.
+     * @returns True while a block set by a person is still running.
+     */
+    get automaticBlockedByUser(): boolean;
     disableAutomatic(c: BlockAutomaticCommand): void;
     disableAutomaticUntil(c: BlockAutomaticUntilCommand): void;
     liftAutomaticBlock(c: BlockAutomaticLiftBlockCommand): void;

package/lib/services/blockAutomaticHandler.js

@@ -16,6 +16,7 @@ class BlockAutomaticHandler {
     constructor(restoreAutomaticCb, _logger) {
         this._logger = _logger;
         this._automaticBlockedUntil = new Date(0);
+        this._blockSetByUser = false;
         this._restoreAutomaticStateTimeout = null;
         this._restoreAutomatic = restoreAutomaticCb;
     }
@@ -28,6 +29,18 @@ class BlockAutomaticHandler {
     get automaticBlockActive() {
         return this._automaticBlockedUntil > new Date();
     }
+    /**
+     * Whether the active block was set by a person rather than by another rule.
+     *
+     * The expiry date alone cannot answer that, and a rule that has to decide whether it may overrule
+     * the current state needs to: at the end of the day the user's choice outranks a configured
+     * automatism. Manual, API and Force all count - they are the same decision reaching the house
+     * through different doors.
+     * @returns True while a block set by a person is still running.
+     */
+    get automaticBlockedByUser() {
+        return this.automaticBlockActive && this._blockSetByUser;
+    }
     disableAutomatic(c) {
         this.disableAutomaticUntil(new command_1.BlockAutomaticUntilCommand(c, new Date(utils_1.Utils.nowMS() + c.durationMS), '', c.onCollideAction, c.revertToAutomaticAtBlockLift));
     }
@@ -41,6 +54,9 @@ class BlockAutomaticHandler {
         }
         this._logger(enums_1.LogLevel.Info, c.logMessage);
         this.automaticBlockedUntil = c.targetDate;
+        // Recorded here rather than derived later: the command is gone once this returns, and the level
+        // that pinned the device is exactly what a rule needs to know before overruling it.
+        this._blockSetByUser = c.isForceAction;
         if (c.revertToAutomaticAtBlockLift) {
             const revertCommand = new command_1.RestoreTargetAutomaticValueCommand(c, 'Restore to automatic state after block.');
             revertCommand.overrideCommandSource = enums_1.CommandSource.Automatic;
@@ -53,6 +69,7 @@ class BlockAutomaticHandler {
     liftAutomaticBlock(c) {
         this.removeRestoreTimeout();
         this.automaticBlockedUntil = new Date(0);
+        this._blockSetByUser = false;
         if (c.revertToAutomatic) {
             this._restoreAutomatic(new command_1.RestoreTargetAutomaticValueCommand(c));
         }