hoffmation-base 0.1.14 → 0.1.18

package/server/devices/groups/smokeGroup.ts

@@ -1,16 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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);
-      }, `Close all Rollos in this room`);
-
-      t.tasten.ObenLinks.addShortCallback((pValue) => {
-        pValue && this._room.FensterGroup.allRolloToLevel(25, true);
-      }, `Nearly closes all Rollos in this room`);
-
-      t.tasten.ObenRechts.addLongCallback((pValue) => {
-        if (!pValue) {
-          return;
-        }
-
-        this._room.FensterGroup.allRolloUp(true);
-      }, `Open all Rollos in this room`);
-
-      t.tasten.ObenRechts.addShortCallback((pValue) => {
-        pValue && this._room.FensterGroup.allRolloToLevel(50, true);
-      }, `All Rollos in this room to middle`);
-
-      t.tasten.MitteLinks.addLongCallback((pValue) => {
-        pValue && this._room.LampenGroup.switchAll(true, true);
-      }, `Turn all Lights in this room on`);
-
-      t.tasten.MitteRechts.addLongCallback((pValue) => {
-        pValue && this._room.LampenGroup.switchAll(false, true);
-      }, `Turn all Lights in this room off`);
-
-      if (this._room.SonosGroup.ownSonosDevices.length > 0) {
-        t.tasten.UntenRechts.addLongCallback(() => {
-          this._room.SonosGroup.trigger(this._room.Einstellungen.radioUrl);
-        });
-      }
-    });
-  }
-}

package/server/devices/groups/waterGroup.ts

@@ -1,16 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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 +0,0 @@
-export enum FensterPosition {
-  geschlossen = 0,
-  kipp = 1,
-  offen = 2,
-}

package/server/devices/hmIPDevices/TuerPosition.ts

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

package/server/devices/hmIPDevices/hmIpBewegung.ts

@@ -1,145 +0,0 @@
-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';
-import { CurrentIlluminationDataPoint } from '../../../models/persistence/CurrentIlluminationDataPoint';
-import { iIlluminationSensor } from '../iIlluminationSensor';
-
-export class HmIpBewegung extends HmIPDevice implements iIlluminationSensor {
-  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 static ILLUMINATION_DURING_MOVEMENT: string = 'CURRENT_ILLUMINATION';
-  private static CURRENT_ILLUMINATION: string = 'ILLUMINATION';
-  private initialized: boolean = false;
-  private fallBackTimeout: NodeJS.Timeout | undefined;
-  private _currentIllumination: number = -1;
-
-  public get currentIllumination(): number {
-    return this._currentIllumination;
-  }
-
-  private set currentIllumination(value: number) {
-    this._currentIllumination = value;
-    Persist.persistCurrentIllumination(
-      new CurrentIlluminationDataPoint(this.info.room, this.info.devID, value, new Date(), this.room?.LampenGroup.anyLightsOwn() ?? false)
-    );
-  }
-
-  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 3 sind relevant
-      return;
-    }
-
-    switch (idSplit[4]) {
-      case HmIpBewegung.MOVEMENT_DETECTION:
-        this.updateMovement(state.val as boolean);
-        break;
-      case HmIpBewegung.CURRENT_ILLUMINATION:
-        this.currentIllumination = state.val as number;
-        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

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

@@ -1,14 +0,0 @@
-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,
-}

package/server/devices/hmIPDevices/hmIpGriff.ts

@@ -1,143 +0,0 @@
-import { LogLevel } from '../../../models/logLevel';
-import { FensterPosition } from './FensterPosition';
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { ServerLogService } from '../../services/log-service';
-import { TelegramService } from '../../services/Telegram/telegram-service';
-import { Utils } from '../../services/utils/utils';
-import { Fenster } from './Fenster';
-import { WeatherService } from '../../services/weather/weather-service';
-
-export class HmIpGriff extends HmIPDevice {
-  public position: FensterPosition = FensterPosition.geschlossen;
-  private _kippCallback: Array<(pValue: boolean) => void> = [];
-  private _closedCallback: Array<(pValue: boolean) => void> = [];
-  private _offenCallback: Array<(pValue: boolean) => void> = [];
-  private _iOpen: NodeJS.Timeout | undefined;
-  private minutesOpen: number = 0;
-  private _fenster: Fenster | undefined = undefined;
-  private _helpingRoomTemp: boolean = false;
-
-  public constructor(pInfo: DeviceInfo) {
-    super(pInfo, HmIpDeviceType.HmIpGriff);
-  }
-
-  public addOffenCallback(pCallback: (pValue: boolean) => void): void {
-    this._offenCallback.push(pCallback);
-  }
-
-  public addKippCallback(pCallback: (pValue: boolean) => void): void {
-    this._kippCallback.push(pCallback);
-  }
-
-  public addClosedCallback(pCallback: (pValue: boolean) => void): void {
-    this._closedCallback.push(pCallback);
-  }
-
-  public set Fenster(value: Fenster) {
-    this._fenster = value;
-  }
-
-  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
-    ServerLogService.writeLog(
-      LogLevel.DeepTrace,
-      `Griff Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`,
-    );
-    super.update(idSplit, state, initial, true);
-    switch (idSplit[3]) {
-      case '1':
-        if (idSplit[4] === 'STATE') {
-          this.updatePosition(state.val as FensterPosition);
-        }
-        break;
-    }
-  }
-
-  public updatePosition(pValue: FensterPosition): void {
-    if (pValue === this.position) {
-      return;
-    }
-
-    ServerLogService.writeLog(
-      LogLevel.Trace,
-      `Update Fenstergriff "${this.info.customName}"\nauf Position "${FensterPosition[pValue]}"`,
-    );
-
-    this.position = pValue;
-    for (const c1 of this._closedCallback) {
-      c1(pValue === 0);
-    }
-
-    for (const c2 of this._kippCallback) {
-      c2(pValue === 1);
-    }
-
-    for (const c3 of this._offenCallback) {
-      c3(pValue === 2);
-    }
-
-    if (pValue === FensterPosition.geschlossen) {
-      if (this._iOpen !== undefined) {
-        clearInterval(this._iOpen);
-        ServerLogService.writeLog(
-          LogLevel.Info,
-          `Fenster: "${this.info.customName}" nach ${this.minutesOpen} Minuten geschlossen`,
-        );
-        this.minutesOpen = 0;
-        this._iOpen = undefined;
-      }
-      return;
-    } else if (this._iOpen === undefined) {
-      this._iOpen = Utils.guardedInterval(
-        () => {
-          this.minutesOpen++;
-          if (this._fenster !== undefined && this._fenster.room !== undefined) {
-            const desiredTemp: number = this._fenster.room.HeatGroup.desiredTemp;
-            const currentTemp: number = this._fenster.room.HeatGroup.currentTemp;
-            const outSideTemp: number = WeatherService.getCurrentTemp();
-
-            // Check if any of these values are unavailable
-            if (desiredTemp > -99 && currentTemp > -99 && outSideTemp > -99) {
-              const wouldHelp: boolean =
-                (desiredTemp < currentTemp && outSideTemp < currentTemp) ||
-                (desiredTemp > currentTemp && outSideTemp > currentTemp);
-              if (!wouldHelp && this._helpingRoomTemp) {
-                const info: string = `Das Fenster "${this.info.customName}" sollte geschlossen werden, es hilft dem Raum nicht mehr`;
-                ServerLogService.writeLog(LogLevel.Info, info);
-                TelegramService.inform(info);
-                this._helpingRoomTemp = false;
-              } else if (wouldHelp && !this._helpingRoomTemp) {
-                this._helpingRoomTemp = true;
-                const info: string = `Das Fenster "${this.info.customName}" hilft der Innentemperatur ihr Ziel von ${desiredTemp} zu erreichen. Draußen sind es ${outSideTemp}. Du wirst informiert wenn es nicht mehr hilft.`;
-                ServerLogService.writeLog(LogLevel.Info, info);
-                TelegramService.inform(info);
-                return;
-              } else if (wouldHelp && this._helpingRoomTemp) {
-                return;
-              }
-            }
-          }
-          const message = `Fenster: "${this.info.customName}" seit ${this.minutesOpen} Minuten auf Position ${
-            FensterPosition[this.position]
-          }`;
-          switch (this.minutesOpen) {
-            case 15:
-            case 30:
-            case 60:
-            case 120:
-            case 240:
-              ServerLogService.writeLog(LogLevel.Info, message);
-              TelegramService.inform(message);
-              break;
-            default:
-              ServerLogService.writeLog(LogLevel.Trace, message);
-              break;
-          }
-        },
-        60000,
-        this,
-      );
-    }
-  }
-}