hoffmation-base 0.1.1 → 0.1.5

package/server/devices/hmIPDevices/Fenster.ts

@@ -1,114 +1,114 @@
-import { LogLevel } from '../../../models/logLevel';
-import { ZigbeeAquaraVibra } from '../zigbee/zigbeeAquaraVibra';
-import { FensterPosition } from './FensterPosition';
-import { HmIpGriff } from './hmIpGriff';
-import { HmIpRoll } from './hmIpRoll';
-import { ServerLogService } from '../../services/log-service';
-import { TimeCallbackService, TimeOfDay } from '../../services/time-callback-service';
-import { Utils } from '../../services/utils/utils';
-import { RoomBase } from '../../../models/rooms/RoomBase';
-
-export class Fenster {
-  public desiredPosition: number = 0;
-
-  /**
-   * sets the desired Pos and moves rollo to this level
-   * @param {number} value
-   */
-  public setDesiredPosition(value: number) {
-    this.desiredPosition = value;
-    this.restoreDesiredPosition();
-  }
-
-  public constructor(
-    public room: RoomBase,
-    public griffe: HmIpGriff[],
-    public vibration: ZigbeeAquaraVibra[],
-    public rollo: HmIpRoll | undefined = undefined,
-    public noRolloOnSunrise: boolean = false,
-  ) {
-    for (const griff of griffe) {
-      griff.addKippCallback((kipp: boolean) => {
-        if (kipp && this.griffeInPosition(FensterPosition.offen) === 0) {
-          this.vibration.forEach((element) => {
-            element.vibrationBlocked = true;
-          });
-          const timeOfDay: TimeOfDay = TimeCallbackService.dayType(this.room.Einstellungen.rolloOffset);
-          if (TimeCallbackService.darkOutsideOrNight(timeOfDay)) {
-            this.rollo?.setLevel(50);
-          } else {
-            this.rollo?.up();
-          }
-        }
-      });
-
-      griff.addOffenCallback((offen: boolean) => {
-        if (offen) {
-          this.vibration.forEach((element) => {
-            element.vibrationBlocked = true;
-          });
-          this.rollo?.up();
-          return;
-        }
-      });
-
-      griff.addClosedCallback((geschlossen: boolean) => {
-        if (
-          geschlossen &&
-          this.griffeInPosition(FensterPosition.offen) === 0 &&
-          this.griffeInPosition(FensterPosition.kipp) === 0
-        ) {
-          const now = new Date().getTime();
-          this.vibration.forEach((element) => {
-            ServerLogService.writeLog(
-              LogLevel.Debug,
-              `Starte Timeout für Vibrationsdeaktivierung für ${element.info.customName}`,
-            );
-            Utils.guardedTimeout(() => {
-              if (element.vibrationBlockedTimeStamp < now) {
-                element.vibrationBlocked = false;
-              }
-            }, 12000);
-          });
-          this.restoreDesiredPosition();
-        }
-      });
-    }
-    Utils.guardedTimeout(
-      () => {
-        if (this.rollo) this.rollo.Fenster = this;
-        for (const g of this.griffe) {
-          g.Fenster = this;
-        }
-      },
-      5,
-      this,
-    );
-  }
-
-  public griffeInPosition(pPosition: FensterPosition): number {
-    let count = 0;
-    for (const griff of this.griffe) {
-      if (griff.position === pPosition) {
-        count++;
-      }
-    }
-    return count;
-  }
-
-  public rolloPositionChange(pValue: number): void {
-    if (!this.room) {
-      ServerLogService.writeLog(LogLevel.Error, `Fenster Rollo Update, but this one is not connected to any room!`);
-      return;
-    }
-    ServerLogService.writeLog(LogLevel.Debug, `Rollo Position Change in ${this.room.roomName} to ${pValue}`);
-
-    if (pValue === 0 || pValue === 100) {
-      this.room.setLightTimeBased(true);
-    }
-  }
-
-  public restoreDesiredPosition() {
-    this.rollo?.setLevel(this.desiredPosition);
-  }
-}
+import { LogLevel } from '../../../models/logLevel';
+import { ZigbeeAquaraVibra } from '../zigbee/zigbeeAquaraVibra';
+import { FensterPosition } from './FensterPosition';
+import { HmIpGriff } from './hmIpGriff';
+import { HmIpRoll } from './hmIpRoll';
+import { ServerLogService } from '../../services/log-service';
+import { TimeCallbackService, TimeOfDay } from '../../services/time-callback-service';
+import { Utils } from '../../services/utils/utils';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+
+export class Fenster {
+  public desiredPosition: number = 0;
+
+  /**
+   * sets the desired Pos and moves rollo to this level
+   * @param {number} value
+   */
+  public setDesiredPosition(value: number) {
+    this.desiredPosition = value;
+    this.restoreDesiredPosition();
+  }
+
+  public constructor(
+    public room: RoomBase,
+    public griffe: HmIpGriff[],
+    public vibration: ZigbeeAquaraVibra[],
+    public rollo: HmIpRoll | undefined = undefined,
+    public noRolloOnSunrise: boolean = false,
+  ) {
+    for (const griff of griffe) {
+      griff.addKippCallback((kipp: boolean) => {
+        if (kipp && this.griffeInPosition(FensterPosition.offen) === 0) {
+          this.vibration.forEach((element) => {
+            element.vibrationBlocked = true;
+          });
+          const timeOfDay: TimeOfDay = TimeCallbackService.dayType(this.room.Einstellungen.rolloOffset);
+          if (TimeCallbackService.darkOutsideOrNight(timeOfDay)) {
+            this.rollo?.setLevel(50);
+          } else {
+            this.rollo?.up();
+          }
+        }
+      });
+
+      griff.addOffenCallback((offen: boolean) => {
+        if (offen) {
+          this.vibration.forEach((element) => {
+            element.vibrationBlocked = true;
+          });
+          this.rollo?.up();
+          return;
+        }
+      });
+
+      griff.addClosedCallback((geschlossen: boolean) => {
+        if (
+          geschlossen &&
+          this.griffeInPosition(FensterPosition.offen) === 0 &&
+          this.griffeInPosition(FensterPosition.kipp) === 0
+        ) {
+          const now = new Date().getTime();
+          this.vibration.forEach((element) => {
+            ServerLogService.writeLog(
+              LogLevel.Debug,
+              `Starte Timeout für Vibrationsdeaktivierung für ${element.info.customName}`,
+            );
+            Utils.guardedTimeout(() => {
+              if (element.vibrationBlockedTimeStamp < now) {
+                element.vibrationBlocked = false;
+              }
+            }, 12000);
+          });
+          this.restoreDesiredPosition();
+        }
+      });
+    }
+    Utils.guardedTimeout(
+      () => {
+        if (this.rollo) this.rollo.Fenster = this;
+        for (const g of this.griffe) {
+          g.Fenster = this;
+        }
+      },
+      5,
+      this,
+    );
+  }
+
+  public griffeInPosition(pPosition: FensterPosition): number {
+    let count = 0;
+    for (const griff of this.griffe) {
+      if (griff.position === pPosition) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  public rolloPositionChange(pValue: number): void {
+    if (!this.room) {
+      ServerLogService.writeLog(LogLevel.Error, `Fenster Rollo Update, but this one is not connected to any room!`);
+      return;
+    }
+    ServerLogService.writeLog(LogLevel.Debug, `Rollo Position Change in ${this.room.roomName} to ${pValue}`);
+
+    if (pValue === 0 || pValue === 100) {
+      this.room.setLightTimeBased(true);
+    }
+  }
+
+  public restoreDesiredPosition() {
+    this.rollo?.setLevel(this.desiredPosition);
+  }
+}

package/server/devices/hmIPDevices/FensterPosition.ts

@@ -1,5 +1,5 @@
-export enum FensterPosition {
-  geschlossen = 0,
-  kipp = 1,
-  offen = 2,
-}
+export enum FensterPosition {
+  geschlossen = 0,
+  kipp = 1,
+  offen = 2,
+}

package/server/devices/hmIPDevices/TuerPosition.ts

@@ -1,4 +1,4 @@
-export enum TuerPosition {
-  geschlossen = 0,
-  offen = 1,
-}
+export enum TuerPosition {
+  geschlossen = 0,
+  offen = 1,
+}

package/server/devices/hmIPDevices/hmIpBewegung.ts

@@ -1,126 +1,126 @@
-import { LogLevel } from '../../../models/logLevel';
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { ServerLogService } from '../../services/log-service';
-import { Persist } from '../../services/dbo/persist';
-import { CountToday } from '../../../models/persistence/todaysCount';
-import { Utils } from '../../services/utils/utils';
-
-export class HmIpBewegung extends HmIPDevice {
-  public excludeFromNightAlarm: boolean = false;
-  public movementDetected: boolean = false;
-  private _detectionsToday: number = 0;
-  private _movementDetectedCallback: Array<(pValue: boolean) => void> = [];
-  private static MOVEMENT_DETECTION: string = 'MOTION';
-  private initialized: boolean = false;
-  private fallBackTimeout: NodeJS.Timeout | undefined;
-
-  public get detectionsToday(): number {
-    return this._detectionsToday;
-  }
-
-  public set detectionsToday(pVal: number) {
-    const oldVal: number = this._detectionsToday;
-    this._detectionsToday = pVal;
-    Persist.persistTodayCount(this, pVal, oldVal);
-  }
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpBewegung);
-    Persist.getCount(this).then((todayCount: CountToday) => {
-      this.detectionsToday = todayCount.counter;
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Bewegungscounter "${this.info.customName}" vorinitialisiert mit ${this.detectionsToday}`,
-      );
-      this.initialized = true;
-    });
-  }
-
-  public addMovementCallback(pCallback: (pValue: boolean) => void): void {
-    this._movementDetectedCallback.push(pCallback);
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(
-      LogLevel.Trace,
-      `Bewegungs Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`,
-    );
-    super.update(idSplit, state, initial, true);
-
-    if (idSplit[3] !== '3') {
-      // Nur die Infos in Kanal 1 sind relevant
-      return;
-    }
-
-    switch (idSplit[4]) {
-      case HmIpBewegung.MOVEMENT_DETECTION:
-        this.updateMovement(state.val as boolean);
-        break;
-    }
-  }
-
-  public updateMovement(pVal: boolean): void {
-    if (!this.initialized && pVal) {
-      ServerLogService.writeLog(
-        LogLevel.Trace,
-        `Bewegung für "${this.info.customName}" erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`,
-      );
-      Utils.guardedTimeout(
-        () => {
-          this.updateMovement(pVal);
-        },
-        1000,
-        this,
-      );
-      return;
-    }
-    if (pVal === this.movementDetected) {
-      ServerLogService.writeLog(
-        LogLevel.Debug,
-        `Überspringe Bewegung für "${this.info.customName}" da bereits der Wert ${pVal} vorliegt`,
-      );
-      if (pVal) {
-        this.resetFallbackTimeout();
-        this.startFallbackTimeout();
-      }
-      return;
-    }
-
-    this.resetFallbackTimeout();
-    this.movementDetected = pVal;
-    ServerLogService.writeLog(LogLevel.Debug, `Neuer Bewegunsstatus Wert für "${this.info.customName}": ${pVal}`);
-    if (pVal) {
-      this.startFallbackTimeout();
-      this.detectionsToday++;
-      ServerLogService.writeLog(
-        LogLevel.Trace,
-        `Dies ist die ${this.detectionsToday} Bewegung für "${this.info.customName}"`,
-      );
-    }
-
-    for (const c of this._movementDetectedCallback) {
-      c(pVal);
-    }
-  }
-
-  private resetFallbackTimeout(): void {
-    if (this.fallBackTimeout) {
-      ServerLogService.writeLog(LogLevel.Trace, `Fallback Timeout für "${this.info.customName}" zurücksetzen`);
-      clearTimeout(this.fallBackTimeout);
-    }
-  }
-
-  private startFallbackTimeout(): void {
-    this.fallBackTimeout = Utils.guardedTimeout(
-      () => {
-        ServerLogService.writeLog(LogLevel.Debug, `Benötige Fallback Bewegungs Reset für "${this.info.customName}"`);
-        this.fallBackTimeout = undefined;
-        this.updateMovement(false);
-      },
-      270000,
-      this,
-    );
-  }
-}
+import { LogLevel } from '../../../models/logLevel';
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { ServerLogService } from '../../services/log-service';
+import { Persist } from '../../services/dbo/persist';
+import { CountToday } from '../../../models/persistence/todaysCount';
+import { Utils } from '../../services/utils/utils';
+
+export class HmIpBewegung extends HmIPDevice {
+  public excludeFromNightAlarm: boolean = false;
+  public movementDetected: boolean = false;
+  private _detectionsToday: number = 0;
+  private _movementDetectedCallback: Array<(pValue: boolean) => void> = [];
+  private static MOVEMENT_DETECTION: string = 'MOTION';
+  private initialized: boolean = false;
+  private fallBackTimeout: NodeJS.Timeout | undefined;
+
+  public get detectionsToday(): number {
+    return this._detectionsToday;
+  }
+
+  public set detectionsToday(pVal: number) {
+    const oldVal: number = this._detectionsToday;
+    this._detectionsToday = pVal;
+    Persist.persistTodayCount(this, pVal, oldVal);
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpBewegung);
+    Persist.getCount(this).then((todayCount: CountToday) => {
+      this.detectionsToday = todayCount.counter;
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Bewegungscounter "${this.info.customName}" vorinitialisiert mit ${this.detectionsToday}`,
+      );
+      this.initialized = true;
+    });
+  }
+
+  public addMovementCallback(pCallback: (pValue: boolean) => void): void {
+    this._movementDetectedCallback.push(pCallback);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.Trace,
+      `Bewegungs Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`,
+    );
+    super.update(idSplit, state, initial, true);
+
+    if (idSplit[3] !== '3') {
+      // Nur die Infos in Kanal 1 sind relevant
+      return;
+    }
+
+    switch (idSplit[4]) {
+      case HmIpBewegung.MOVEMENT_DETECTION:
+        this.updateMovement(state.val as boolean);
+        break;
+    }
+  }
+
+  public updateMovement(pVal: boolean): void {
+    if (!this.initialized && pVal) {
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Bewegung für "${this.info.customName}" erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`,
+      );
+      Utils.guardedTimeout(
+        () => {
+          this.updateMovement(pVal);
+        },
+        1000,
+        this,
+      );
+      return;
+    }
+    if (pVal === this.movementDetected) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Überspringe Bewegung für "${this.info.customName}" da bereits der Wert ${pVal} vorliegt`,
+      );
+      if (pVal) {
+        this.resetFallbackTimeout();
+        this.startFallbackTimeout();
+      }
+      return;
+    }
+
+    this.resetFallbackTimeout();
+    this.movementDetected = pVal;
+    ServerLogService.writeLog(LogLevel.Debug, `Neuer Bewegunsstatus Wert für "${this.info.customName}": ${pVal}`);
+    if (pVal) {
+      this.startFallbackTimeout();
+      this.detectionsToday++;
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Dies ist die ${this.detectionsToday} Bewegung für "${this.info.customName}"`,
+      );
+    }
+
+    for (const c of this._movementDetectedCallback) {
+      c(pVal);
+    }
+  }
+
+  private resetFallbackTimeout(): void {
+    if (this.fallBackTimeout) {
+      ServerLogService.writeLog(LogLevel.Trace, `Fallback Timeout für "${this.info.customName}" zurücksetzen`);
+      clearTimeout(this.fallBackTimeout);
+    }
+  }
+
+  private startFallbackTimeout(): void {
+    this.fallBackTimeout = Utils.guardedTimeout(
+      () => {
+        ServerLogService.writeLog(LogLevel.Debug, `Benötige Fallback Bewegungs Reset für "${this.info.customName}"`);
+        this.fallBackTimeout = undefined;
+        this.updateMovement(false);
+      },
+      270000,
+      this,
+    );
+  }
+}