hoffmation-base 3.6.0 → 3.6.1

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.js

@@ -340,6 +340,17 @@ class AcDevice extends devices_1.RoomBaseDevice {
         if (!this.settings.noCoolingOnMovement || !this.on || this.mode === enums_1.AcMode.Heating) {
             return;
         }
+        // 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)));
     }
     /**

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));
         }