hoffmation-base 0.0.1

package/server/devices/groups/praesenzGroup.ts

@@ -0,0 +1,182 @@
+import { HmIpPraezenz } from '../hmIPDevices/hmIpPraezenz';
+import { HmIpBewegung } from '../hmIPDevices/hmIpBewegung';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { TimeCallback, TimeCallbackType } from '../../../models/timeCallback';
+import { ServerLogService } from '../../services/log-service';
+import { LogLevel } from '../../../models/logLevel';
+import { TimeCallbackService } from '../../services/time-callback-service';
+import { Utils } from '../../services/utils/utils';
+
+export class PraesenzGroup {
+  private _lastMovement: Date = new Date(0);
+
+  public constructor(private _room: RoomBase, public Prasenzen: HmIpPraezenz[], public Bewegungen: HmIpBewegung[]) {
+    for (const b of [...Prasenzen, ...Bewegungen]) {
+      b.room = this._room;
+    }
+  }
+
+  public initCallbacks(): void {
+    this.Prasenzen.forEach((p) => {
+      p.addPresenceCallback((val) => {
+        if (!val) {
+          return;
+        }
+        if (RoomBase.awayModeActive || (RoomBase.nightAlarmActive && !p.excludeFromNightAlarm)) {
+          RoomBase.startIntrusionAlarm(this._room, p);
+        }
+        RoomBase.movementHistory.add(`${Utils.nowString()}: Raum "${this._room.roomName}" Gerät "${p.info.fullName}"`);
+      });
+    });
+    this.Bewegungen.forEach((b) => {
+      b.addMovementCallback((val) => {
+        if (!val) {
+          return;
+        }
+        if (RoomBase.awayModeActive || (RoomBase.nightAlarmActive && !b.excludeFromNightAlarm)) {
+          RoomBase.startIntrusionAlarm(this._room, b);
+        }
+        RoomBase.movementHistory.add(`${Utils.nowString()}: Raum "${this._room.roomName}" Gerät "${b.info.fullName}"`);
+      });
+    });
+    if (this._room.Einstellungen.lichtSonnenAufgangAus && this._room.Einstellungen.lampOffset) {
+      this._room.sonnenAufgangLichtCallback = new TimeCallback(
+        `${this._room.roomName} Morgens Lampe aus`,
+        TimeCallbackType.Sunrise,
+        () => {
+          ServerLogService.writeLog(
+            LogLevel.Info,
+            `Es ist hell genug --> Schalte Lampen im ${this._room.roomName} aus`,
+          );
+          this._room.LampenGroup.switchAll(false);
+        },
+        this._room.Einstellungen.lampOffset.sunrise,
+      );
+      TimeCallbackService.addCallback(this._room.sonnenAufgangLichtCallback);
+    }
+
+    this.addLastLeftCallback(() => {
+      this._room.LampenGroup.switchAll(false);
+    });
+
+    if (this._room.Einstellungen.lampenBeiBewegung) {
+      this.addFirstEnterCallback(() => {
+        ServerLogService.writeLog(
+          LogLevel.DeepTrace,
+          `Bewegung im Raum ${this._room.roomName} festgestellt --> Licht einschalten`,
+        );
+        this._room.setLightTimeBased();
+      });
+    }
+  }
+
+  public presentAmount(): number {
+    let count = 0;
+    for (let i = 0; i < this.Prasenzen.length; i++) {
+      if (this.Prasenzen[i].presenceDetected) {
+        count++;
+      }
+    }
+    for (let i = 0; i < this.Bewegungen.length; i++) {
+      if (this.Bewegungen[i].movementDetected) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+  public anyPresent(): boolean {
+    for (let i = 0; i < this.Prasenzen.length; i++) {
+      if (this.Prasenzen[i].presenceDetected) {
+        return true;
+      }
+    }
+    for (let i = 0; i < this.Bewegungen.length; i++) {
+      if (this.Bewegungen[i].movementDetected) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  public lastLeftCB(val: boolean, cb: () => void): void {
+    if (val) {
+      return;
+    }
+
+    if (this.anyPresent()) {
+      return;
+    }
+
+    let timeAfterReset: number =
+      Utils.nowMS() - this._lastMovement.getTime() - this._room.Einstellungen.movementResetTimer * 1000;
+    if (timeAfterReset > 0) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Movement reset in ${
+          this._room.roomName
+        }.\nActive Motions: ${this.presentAmount()}\nTime after Last Movement including Reset: ${timeAfterReset}`,
+      );
+      cb();
+      return;
+    }
+    ServerLogService.writeLog(LogLevel.Debug, `Movement reset in ${this._room.roomName} delayed.`);
+    Utils.guardedTimeout(
+      () => {
+        timeAfterReset =
+          Utils.nowMS() - this._lastMovement.getTime() - this._room.Einstellungen.movementResetTimer * 1000;
+        ServerLogService.writeLog(
+          LogLevel.Debug,
+          `Delayed Movement reset in ${
+            this._room.roomName
+          }.\nActive Motions: ${this.presentAmount()}\nTime after Last Movement including Reset: ${timeAfterReset}`,
+        );
+        if (!this.anyPresent() && timeAfterReset > 0) {
+          cb();
+        }
+      },
+      Math.abs(timeAfterReset) + 500,
+      this,
+    );
+  }
+
+  public addLastLeftCallback(cb: () => void): void {
+    this.Prasenzen.forEach((p) => {
+      p.addPresenceCallback((val) => {
+        this.lastLeftCB(val, cb);
+      });
+    });
+    this.Bewegungen.forEach((b) => {
+      b.addMovementCallback((val) => {
+        this.lastLeftCB(val, cb);
+      });
+    });
+  }
+
+  private firstEnterCallback(val: boolean, cb: () => void): void {
+    if (!val) {
+      return;
+    }
+    this._lastMovement = new Date();
+    if (this.presentAmount() > 1) {
+      return;
+    }
+
+    cb();
+  }
+
+  public addFirstEnterCallback(cb: () => void): void {
+    this.Prasenzen.forEach((p) => {
+      p.addPresenceCallback((val) => {
+        this.firstEnterCallback(val, cb);
+      });
+    });
+    this.Bewegungen.forEach((b) => {
+      b.addMovementCallback((val) => {
+        this.firstEnterCallback(val, cb);
+      });
+    });
+  }
+}

package/server/devices/groups/smokeGroup.ts

@@ -0,0 +1,16 @@
+import { ZigbeeHeimanSmoke } from '../zigbee/zigbeeHeimanSmoke';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+
+export class SmokeGroup {
+  public constructor(private _room: RoomBase, public Rauchmelder: Array<ZigbeeHeimanSmoke>) {
+    for (const s of [...this.Rauchmelder]) {
+      s.room = this._room;
+    }
+  }
+
+  public stopAlarm(): void {
+    for (const d of this.Rauchmelder) {
+      d.stopAlarm(true);
+    }
+  }
+}

package/server/devices/groups/sonosGroup.ts

@@ -0,0 +1,33 @@
+import { OwnSonosDevice } from '../../services/Sonos/sonos-service';
+import { Utils } from '../../services/utils/utils';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+
+export class SonosGroup {
+  private _playing: boolean = false;
+  public constructor(private _room: RoomBase, public ownSonosDevices: OwnSonosDevice[]) {}
+
+  public playRadio(radioUrl: string): void {
+    this.ownSonosDevices.forEach((s) => {
+      Utils.guardedTimeout(() => {
+        s.device?.SetAVTransportURI(radioUrl);
+      }, 1500);
+    });
+    this._playing = true;
+  }
+
+  public turnOff(): void {
+    this.ownSonosDevices.forEach((s) => {
+      s.device?.Stop();
+    });
+    this._playing = false;
+  }
+
+  public trigger(track: string): void {
+    if (this._playing) {
+      this.turnOff();
+      return;
+    }
+
+    this.playRadio(track);
+  }
+}

package/server/devices/groups/tasterGroup.ts

@@ -0,0 +1,48 @@
+import { HmIpTaster } from '../hmIPDevices/hmIpTaster';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+
+export class TasterGroup {
+  public constructor(private _room: RoomBase, public Taster: HmIpTaster[]) {
+    for (const t of [...Taster]) {
+      t.room = this._room;
+    }
+  }
+
+  public initCallbacks(): void {
+    this.Taster.forEach((t) => {
+      t.tasten.ObenLinks.addLongCallback((pValue) => {
+        pValue && this._room.FensterGroup.allRolloDown(false, true);
+      });
+
+      t.tasten.ObenLinks.addShortCallback((pValue) => {
+        pValue && this._room.FensterGroup.allRolloToLevel(25, true);
+      });
+
+      t.tasten.ObenRechts.addLongCallback((pValue) => {
+        if (!pValue) {
+          return;
+        }
+
+        this._room.FensterGroup.allRolloUp(true);
+      });
+
+      t.tasten.ObenRechts.addShortCallback((pValue) => {
+        pValue && this._room.FensterGroup.allRolloToLevel(50, true);
+      });
+
+      t.tasten.MitteLinks.addLongCallback((pValue) => {
+        pValue && this._room.LampenGroup.switchAll(true, true);
+      });
+
+      t.tasten.MitteRechts.addLongCallback((pValue) => {
+        pValue && this._room.LampenGroup.switchAll(false, true);
+      });
+
+      if (this._room.SonosGroup.SNDevices.length > 0) {
+        t.tasten.UntenRechts.addLongCallback(() => {
+          this._room.SonosGroup.trigger(this._room.Einstellungen.radioUrl);
+        });
+      }
+    });
+  }
+}

package/server/devices/groups/waterGroup.ts

@@ -0,0 +1,16 @@
+import { ZigbeeAquaraWater } from '../zigbee/zigbeeAquaraWater';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+
+export class WaterGroup {
+  public constructor(private _room: RoomBase, public WaterDetectors: Array<ZigbeeAquaraWater>) {
+    for (const w of [...WaterDetectors]) {
+      w.room = this._room;
+    }
+  }
+
+  public stopAlarm(): void {
+    for (const d of this.WaterDetectors) {
+      d.stopAlarm(true);
+    }
+  }
+}

package/server/devices/hmIPDevices/Fenster.ts

@@ -0,0 +1,114 @@
+import { ZigbeeAquaraVibra } from '../zigbee/zigbeeAquaraVibra';
+import { FensterPosition } from './FensterPosition';
+import { HmIpGriff } from './hmIpGriff';
+import { HmIpRoll } from './hmIpRoll';
+import { LogLevel } from '../../../models/logLevel';
+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

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

package/server/devices/hmIPDevices/TuerPosition.ts

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

package/server/devices/hmIPDevices/hmIpBewegung.ts

@@ -0,0 +1,126 @@
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { LogLevel } from '../../../models/logLevel';
+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,
+    );
+  }
+}

package/server/devices/hmIPDevices/hmIpDevice.ts

@@ -0,0 +1,90 @@
+import { DeviceInfo } from '../DeviceInfo';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { LogLevel } from '../../../models/logLevel';
+import { HmIpAddDeviceItem, HmIpRoomSettings } from '../../../models/rooms/RoomSettings/hmIPRoomSettings';
+import { ServerLogService } from '../../services/log-service';
+import { ioBrokerBaseDevice } from '../iIoBrokerDevice';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+
+export class HmIPDevice extends ioBrokerBaseDevice {
+  public static roomSettings: { [id: string]: HmIpRoomSettings } = {};
+  public lowBattery: boolean = false;
+  public deviceType: HmIpDeviceType;
+  public room: RoomBase | undefined = undefined;
+
+  public static addRoom(shortName: string, settings: HmIpRoomSettings): void {
+    if (this.roomSettings[shortName] !== undefined) {
+      ServerLogService.writeLog(
+        LogLevel.Alert,
+        `Es gibt bereits ein Registrat für HmIpRoomsettings für den Raumnamen "${shortName}"`,
+      );
+      return;
+    }
+    this.roomSettings[shortName] = settings;
+  }
+
+  public static checkMissing(): void {
+    for (const rName in this.roomSettings) {
+      this.roomSettings[rName].checkMissing();
+    }
+  }
+
+  public constructor(pInfo: DeviceInfo, pType: HmIpDeviceType) {
+    super(pInfo);
+    this.deviceType = pType;
+    this.addToCorrectRoom();
+  }
+
+  protected addToCorrectRoom(): void {
+    const settings: HmIpRoomSettings | undefined = HmIPDevice.roomSettings[this.info.room];
+    if (settings !== undefined) {
+      if (settings.devices[this.deviceType] === undefined) {
+        ServerLogService.missingRoomHandling(settings.RoomName, this.deviceType);
+        return;
+      }
+      const deviceSettings: HmIpAddDeviceItem | undefined =
+        settings.devices[this.deviceType][this.info.deviceRoomIndex];
+      if (deviceSettings === undefined) {
+        ServerLogService.missingRoomIndexHandling(settings.RoomName, this.info.deviceRoomIndex, this.deviceType);
+        return;
+      }
+
+      if (deviceSettings.customName !== undefined) {
+        this.info.customName = deviceSettings.customName;
+      }
+      deviceSettings.setID(this.info.devID);
+      deviceSettings.added = true;
+      ServerLogService.addedDeviceToRoom(settings.RoomName, this.deviceType, this.info.deviceRoomIndex);
+      return;
+    }
+    switch (this.info.room) {
+      default:
+        ServerLogService.writeLog(LogLevel.Warn, `${this.info.room} is noch kein bekannter Raum`);
+    }
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false, pOverride: boolean = false): void {
+    if (!pOverride) {
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Keine Update Überschreibung für "${this.info.customName}":\n\tID: ${idSplit.join(
+          '.',
+        )}\n\tData: ${JSON.stringify(state)}`,
+      );
+    }
+
+    if (idSplit[3] !== '0') {
+      // Dies ist etwas Gerätespezifisches
+      return;
+    }
+
+    switch (idSplit[4]) {
+      case 'LOW_BAT':
+        const newBatLowVal: boolean = state.val as boolean;
+        if (newBatLowVal) {
+          ServerLogService.writeLog(LogLevel.Alert, `!!BATTERIE FAST LEER!! "${this.info.customName}"`);
+        }
+        break;
+    }
+  }
+}

package/server/devices/hmIPDevices/hmIpDeviceType.ts

@@ -0,0 +1,14 @@
+export enum HmIpDeviceType {
+  unknown = 0,
+  HmIpLampe = 1,
+  HmIpTaster = 2,
+  HmIpRoll = 3,
+  HmIpTherm = 4,
+  HmIpPraezenz = 5,
+  HmIpGriff = 6,
+  HmIpWippe = 7,
+  HmIpHeizung = 8,
+  HmIpTuer = 9,
+  HmIpHeizgruppe = 10,
+  HmIpBewegung = 11,
+}