hoffmation-base 0.0.1

package/server/devices/hmIPDevices/hmIpRoll.ts

@@ -0,0 +1,133 @@
+import { Fenster } from './Fenster';
+import { FensterPosition } from './FensterPosition';
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { Utils } from '/server/services/utils/utils';
+
+export class HmIpRoll extends HmIPDevice {
+  public get currentLevel(): number {
+    if (this._setLevel !== -1 && this._currentLevel !== this._setLevel) {
+      return this._setLevel;
+    }
+    return this._currentLevel;
+  }
+
+  public set currentLevel(value: number) {
+    if (value !== this._setLevel && Utils.nowMS() - this._setLevelTime < 60 * 10000) {
+      value = this._setLevel;
+    }
+    if (value !== this._currentLevel && this._fenster) {
+      Utils.guardedNewThread(() => {
+        this._fenster?.rolloPositionChange(value);
+      }, this);
+    }
+    this._currentLevel = value;
+  }
+
+  public get desiredFensterLevel(): number {
+    if (this._fenster === undefined) {
+      return -1;
+    }
+    return this._fenster.desiredPosition;
+  }
+
+  private _currentLevel: number = -1;
+  private _setLevelSwitchID: string;
+  private _fenster?: Fenster;
+  private _firstCommandRecieved: boolean = false;
+  private _setLevel: number = -1;
+  private _setLevelTime: number = -1;
+
+  public set Fenster(value: Fenster) {
+    this._fenster = value;
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpRoll);
+    this._setLevelSwitchID = `${this.info.fullID}.4.LEVEL`;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.DeepTrace,
+      `Rollo Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
+    );
+    super.update(idSplit, state, initial, true);
+    switch (idSplit[3]) {
+      case '3':
+        if (idSplit[4] === 'LEVEL') {
+          this.currentLevel = state.val as number;
+        }
+        break;
+    }
+  }
+
+  public setLevel(pPosition: number, initial: boolean = false, skipOpenWarning: boolean = false): void {
+    if (!this._firstCommandRecieved && !initial) {
+      this._firstCommandRecieved = true;
+    }
+    if (this._firstCommandRecieved && initial) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Skipped initial Rollo "${this.info.customName}" to ${pPosition} as we recieved a command already`,
+      );
+      return;
+    }
+    if (this.currentLevel === pPosition) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Skip Rollo command for "${this.info.customName}" to Position ${pPosition} as this is the current one`,
+      );
+      return;
+    }
+    if (this._setLevelSwitchID === '') {
+      console.error(`Keine Switch ID für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!this.ioConn) {
+      console.error(`Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (this._fenster !== undefined) {
+      if (this._fenster.griffeInPosition(FensterPosition.offen) > 0 && pPosition < 100) {
+        if (!skipOpenWarning) {
+          ServerLogService.writeLog(
+            LogLevel.Alert,
+            `Fahre Rollo "${this.info.customName}" nicht runter, weil das Fenster offen ist!`,
+          );
+        }
+        return;
+      }
+      if (this._fenster.griffeInPosition(FensterPosition.kipp) > 0 && pPosition < 50) {
+        pPosition = 50;
+        if (!skipOpenWarning) {
+          ServerLogService.writeLog(
+            LogLevel.Alert,
+            `Fahre Rollo "${this.info.customName}" nicht runter, weil das Fenster auf Kipp ist!`,
+          );
+        }
+      }
+    }
+
+    this._setLevel = pPosition;
+    ServerLogService.writeLog(LogLevel.Debug, `Fahre Rollo "${this.info.customName}" auf Position ${pPosition}`);
+    this.ioConn.setState(this._setLevelSwitchID, pPosition);
+  }
+
+  public down(initial: boolean = false): void {
+    this.setLevel(0, initial);
+  }
+
+  public middle(): void {
+    this.setLevel(50);
+  }
+
+  public up(initial: boolean = false): void {
+    this.setLevel(100, initial);
+  }
+}

package/server/devices/hmIPDevices/hmIpTaste.ts

@@ -0,0 +1,72 @@
+import { Utils } from '/server/services/utils/utils';
+
+export class HmIPTaste {
+  public shortPressed: boolean = false;
+  public longPressed: boolean = false;
+  private _shortCallback: Array<(pValue: boolean) => void> = [];
+  private _longCallback: Array<(pValue: boolean) => void> = [];
+  private _shortResetTimeout: null | NodeJS.Timeout = null;
+  private _longResetTimeout: null | NodeJS.Timeout = null;
+
+  public constructor(public updateIndex: number) {}
+
+  public addShortCallback(pCallback: (pValue: boolean) => void): void {
+    this._shortCallback.push(pCallback);
+  }
+
+  public addLongCallback(pCallback: (pValue: boolean) => void): void {
+    this._longCallback.push(pCallback);
+  }
+
+  public updateShort(pValue: boolean): void {
+    if (pValue === this.shortPressed) {
+      return;
+    }
+
+    this.shortPressed = pValue;
+
+    for (const c of this._shortCallback) {
+      c(pValue);
+    }
+
+    if (!pValue) {
+      return;
+    }
+
+    this._shortResetTimeout !== null && clearTimeout(this._shortResetTimeout);
+
+    this._shortResetTimeout = Utils.guardedTimeout(
+      () => {
+        this.updateShort(false);
+      },
+      1000,
+      this,
+    );
+  }
+
+  public updateLong(pValue: boolean): void {
+    if (pValue === this.longPressed) {
+      return;
+    }
+
+    this.longPressed = pValue;
+
+    for (const c of this._longCallback) {
+      c(pValue);
+    }
+
+    if (!pValue) {
+      return;
+    }
+
+    this._longResetTimeout !== null && clearTimeout(this._longResetTimeout);
+
+    this._longResetTimeout = Utils.guardedTimeout(
+      () => {
+        this.updateLong(false);
+      },
+      5000,
+      this,
+    );
+  }
+}

package/server/devices/hmIPDevices/hmIpTaster.ts

@@ -0,0 +1,73 @@
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { HmIPTaste } from './hmIpTaste';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+
+export class HmIpTaster extends HmIPDevice {
+  public tasten: {
+    ObenLinks: HmIPTaste;
+    ObenRechts: HmIPTaste;
+    MitteLinks: HmIPTaste;
+    MitteRechts: HmIPTaste;
+    UntenLinks: HmIPTaste;
+    UntenRechts: HmIPTaste;
+  } = {
+    ObenLinks: new HmIPTaste(1),
+    ObenRechts: new HmIPTaste(2),
+    MitteLinks: new HmIPTaste(3),
+    MitteRechts: new HmIPTaste(4),
+    UntenLinks: new HmIPTaste(5),
+    UntenRechts: new HmIPTaste(6),
+  };
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpTaster);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(LogLevel.Trace, `Taster Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+    super.update(idSplit, state, initial, true);
+    let cTaste: HmIPTaste | undefined = undefined;
+    switch (idSplit[3]) {
+      case '1':
+        cTaste = this.tasten.ObenLinks;
+        break;
+      case '2':
+        cTaste = this.tasten.ObenRechts;
+        break;
+      case '3':
+        cTaste = this.tasten.MitteLinks;
+        break;
+      case '4':
+        cTaste = this.tasten.MitteRechts;
+        break;
+      case '5':
+        cTaste = this.tasten.UntenLinks;
+        break;
+      case '6':
+        cTaste = this.tasten.UntenRechts;
+        break;
+    }
+
+    if (cTaste === undefined) {
+      return;
+    }
+
+    switch (idSplit[4]) {
+      case 'PRESS_SHORT':
+        if (!initial) {
+          // Tasten beim Starten ignorieren
+          cTaste.updateShort(state.val as boolean);
+        }
+        break;
+      case 'PRESS_LONG':
+        if (!initial) {
+          // Tasten beim Starten ignorieren
+          cTaste.updateLong(state.val as boolean);
+        }
+        break;
+    }
+  }
+}

package/server/devices/hmIPDevices/hmIpTherm.ts

@@ -0,0 +1,19 @@
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+
+export class HmIpTherm extends HmIPDevice {
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpTherm);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.Trace,
+      `Thermostat "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
+    );
+    super.update(idSplit, state, initial, true);
+  }
+}

package/server/devices/hmIPDevices/hmIpTuer.ts

@@ -0,0 +1,115 @@
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { TuerPosition } from './TuerPosition';
+import { SonosService } from '/server/services/Sonos/sonos-service';
+import { TelegramService } from '/server/services/Telegram/telegram-service';
+import { Utils } from '/server/services/utils/utils';
+
+export class HmIpTuer extends HmIPDevice {
+  public position: TuerPosition = TuerPosition.geschlossen;
+  private _closedCallback: Array<(pValue: boolean) => void> = [];
+  private _offenCallback: Array<(pValue: boolean) => void> = [];
+  private _iOpen: NodeJS.Timeout | undefined;
+  private minutesOpen: number = 0;
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpTuer);
+  }
+
+  public addOffenCallback(pCallback: (pValue: boolean) => void): void {
+    this._offenCallback.push(pCallback);
+  }
+
+  public addClosedCallback(pCallback: (pValue: boolean) => void): void {
+    this._closedCallback.push(pCallback);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.DeepTrace,
+      `Tuer Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`,
+    );
+    super.update(idSplit, state, initial, true);
+    switch (idSplit[3]) {
+      case '1':
+        if (idSplit[4] === 'STATE') {
+          if (initial) {
+            this.position = TuerPosition.geschlossen;
+            return;
+          }
+          this.updatePosition(state.val as TuerPosition);
+        }
+        break;
+    }
+  }
+
+  public updatePosition(pValue: TuerPosition): void {
+    if (pValue === this.position) {
+      return;
+    }
+
+    ServerLogService.writeLog(
+      LogLevel.Trace,
+      `Update Tür "${this.info.customName}"\nauf Position "${TuerPosition[pValue]}"`,
+    );
+
+    this.position = pValue;
+    for (const c1 of this._closedCallback) {
+      c1(pValue === 0);
+    }
+
+    for (const c2 of this._offenCallback) {
+      c2(pValue === 1);
+    }
+
+    if (pValue === TuerPosition.geschlossen) {
+      if (this._iOpen !== undefined) {
+        clearInterval(this._iOpen);
+
+        let message = `Die Haustür ist nun nach ${this.minutesOpen} Minuten wieder zu!`;
+        if (this.minutesOpen === 0) {
+          message = 'Die Haustür ist wieder zu.';
+        }
+        // const message: string = `Die Tür mit dem Namen "${this.info.customName}" wurde nach ${this.minutesOpen} Minuten geschlossen!`;
+        ServerLogService.writeLog(LogLevel.Info, message);
+
+        TelegramService.inform(message);
+        this.minutesOpen = 0;
+        this._iOpen = undefined;
+      }
+      return;
+    } else if (this._iOpen === undefined) {
+      const message = `Die Haustür wurde geöffnet!`;
+      //const message: string = `Die Tür mit dem Namen "${this.info.customName}" wurde geöfnet!`
+      TelegramService.inform(message);
+      SonosService.speakOnAll(message, 40);
+      this._iOpen = Utils.guardedInterval(
+        () => {
+          this.minutesOpen++;
+          const message = `Tuer: "${this.info.customName}" seit ${this.minutesOpen} Minuten auf Position ${
+            TuerPosition[this.position]
+          }`;
+          switch (this.minutesOpen) {
+            case 2:
+            case 5:
+            case 10:
+            case 20:
+            case 45:
+            case 60:
+              ServerLogService.writeLog(LogLevel.Info, message);
+              TelegramService.inform(message);
+              break;
+            default:
+              ServerLogService.writeLog(LogLevel.Trace, message);
+              break;
+          }
+        },
+        60000,
+        this,
+      );
+    }
+  }
+}

package/server/devices/hmIPDevices/hmIpWippe.ts

@@ -0,0 +1,55 @@
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { HmIPTaste } from './hmIpTaste';
+import { LogLevel } from '../../../models/logLevel';
+import { ServerLogService } from '../../services/log-service';
+
+export class HmIpWippe extends HmIPDevice {
+  public tasten: {
+    Unten: HmIPTaste;
+    Oben: HmIPTaste;
+  } = {
+    Unten: new HmIPTaste(1),
+    Oben: new HmIPTaste(2),
+  };
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpWippe);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(LogLevel.Trace, `Wippe Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+    super.update(idSplit, state, initial, true);
+    let cTaste: HmIPTaste | undefined = undefined;
+    switch (idSplit[3]) {
+      case '1':
+        cTaste = this.tasten.Unten;
+        break;
+      case '2':
+        cTaste = this.tasten.Oben;
+        break;
+    }
+
+    if (cTaste === undefined) {
+      return;
+    }
+
+    switch (idSplit[4]) {
+      case 'PRESS_SHORT':
+        if (!initial) {
+          // Tasten beim Starten ignorieren
+          ServerLogService.writeLog(LogLevel.Debug, `Tasten Update initial für "${this.info.customName}" ignoriert`);
+          cTaste.updateShort(state.val as boolean);
+        }
+        break;
+      case 'PRESS_LONG':
+        if (!initial) {
+          // Tasten beim Starten ignorieren
+          ServerLogService.writeLog(LogLevel.Debug, `Tasten Update initial für "${this.info.customName}" ignoriert`);
+          cTaste.updateLong(state.val as boolean);
+        }
+        break;
+    }
+  }
+}

package/server/devices/iDeviceUpdater.ts

@@ -0,0 +1,4 @@
+export interface IDeviceUpdater {
+  updateState(id: string, state: ioBroker.State, initial?: boolean): void;
+  updateObject(pId: string, pObj: ioBroker.Object): void;
+}

package/server/devices/iIoBrokerDevice.ts

@@ -0,0 +1,44 @@
+import { DeviceInfo } from './DeviceInfo';
+import { IOBrokerConnection } from '../ioBroker/connection';
+
+export abstract class ioBrokerBaseDevice {
+  private _ioConnection?: IOBrokerConnection;
+
+  protected constructor(private _info: DeviceInfo) {}
+
+  /**
+   * Getter info
+   * @return {TradFriInfo}
+   */
+  public get info(): DeviceInfo {
+    return this._info;
+  }
+
+  /**
+   * Setter info
+   * @param {TradFriInfo} value
+   */
+  public set info(value: DeviceInfo) {
+    this._info = value;
+  }
+
+  /**
+   * Getter ioConn
+   * @return {IOBrokerConnection}
+   */
+  public get ioConn(): IOBrokerConnection | undefined {
+    return this._ioConnection;
+  }
+
+  /**
+   * Setter ioConn
+   * @param {IOBrokerConnection} value
+   */
+  public set ioConn(value: IOBrokerConnection | undefined) {
+    this._ioConnection = value;
+  }
+
+  protected abstract addToCorrectRoom(): void;
+
+  protected abstract update(idSplit: string[], state: ioBroker.State, initial: boolean, pOverride: boolean): void;
+}

package/server/devices/wledDevice.ts

@@ -0,0 +1,124 @@
+import { IOBrokerConnection } from '../ioBroker/connection';
+import { DeviceInfo } from './DeviceInfo';
+import { LogLevel } from '/models/logLevel';
+import { ServerLogService } from '/server/services/log-service';
+
+export class WledDevice {
+  public on: boolean = false;
+  public brightness: number = -1;
+  public linkQuality: number = 0;
+  public battery: number = -1;
+  public voltage: string = '';
+  private _info: DeviceInfo;
+  private _ioConnection?: IOBrokerConnection;
+  private _onID: string;
+  private _brightnessID: string;
+
+  public constructor(pInfo: DeviceInfo) {
+    this._info = pInfo;
+    this.addToCorrectRoom();
+    this._onID = `${this.info.fullID}.on`;
+    this._brightnessID = `${this.info.fullID}.bri`;
+  }
+
+  /**
+   * Getter info
+   * @return {DeviceInfo}
+   */
+  public get info(): DeviceInfo {
+    return this._info;
+  }
+
+  /**
+   * Setter info
+   * @param {DeviceInfo} value
+   */
+  public set info(value: DeviceInfo) {
+    this._info = value;
+  }
+
+  /**
+   * Getter ioConn
+   * @return {IOBrokerConnection}
+   */
+  public get ioConn(): IOBrokerConnection | undefined {
+    return this._ioConnection;
+  }
+
+  /**
+   * Setter ioConn
+   * @param {IOBrokerConnection} value
+   */
+  public set ioConn(value: IOBrokerConnection | undefined) {
+    this._ioConnection = value;
+  }
+
+  private addToCorrectRoom(): void {
+    ServerLogService.writeLog(LogLevel.DeepTrace, `Neues Zigbee Gerät für ${this._info.room}`);
+    switch (this._info.room) {
+      case 'Wohnz':
+        // room1OGWohn.addWLED(this._info);
+        break;
+      default:
+        console.warn(`${this._info.room} ist noch kein bekannter Raum für WLED Geräte`);
+    }
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false, pOverride: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.DeepTrace,
+      `Wled:Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
+    );
+    if (!pOverride) {
+      ServerLogService.writeLog(
+        LogLevel.Warn,
+        `Keine Update Überschreibung für "${this.info.customName}":\n\tID: ${idSplit.join(
+          '.',
+        )}\n\tData: ${JSON.stringify(state)}`,
+      );
+    }
+
+    switch (idSplit[3]) {
+      case 'on':
+        this.on = state.val as boolean;
+        break;
+      case 'bri':
+        this.brightness = state.val as number;
+        break;
+    }
+  }
+
+  public setLight(pValue: boolean, brightness: number = -1): void {
+    if (this._onID === '') {
+      ServerLogService.writeLog(LogLevel.Error, `Keine On ID für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (!this.ioConn) {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    if (pValue && brightness === -1 && this.brightness < 10) {
+      brightness = 10;
+    }
+    ServerLogService.writeLog(
+      LogLevel.Debug,
+      `WLED Schalten: "${this.info.customName}" An: ${pValue}\tHelligkeit: ${brightness}%`,
+    );
+
+    this.ioConn.setState(this._onID, pValue, (err) => {
+      if (err) {
+        ServerLogService.writeLog(LogLevel.Error, `WLED schalten ergab Fehler: ${err}`);
+      }
+    });
+
+    if (brightness > -1) {
+      this.ioConn.setState(this._brightnessID, brightness, (err) => {
+        if (err) {
+          ServerLogService.writeLog(LogLevel.Error, `Dimmer Helligkeit schalten ergab Fehler: ${err}`);
+        }
+      });
+    }
+  }
+}