hoffmation-base 3.5.0 → 3.6.0

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/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,35 @@ 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.'));
+        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) {