hoffmation-base 0.1.1 → 0.1.5

package/server/devices/hmIPDevices/hmIpTuer.ts

@@ -1,115 +1,115 @@
-import { HmIPDevice } from './hmIpDevice';
-import { HmIpDeviceType } from './hmIpDeviceType';
-import { DeviceInfo } from '../DeviceInfo';
-import { LogLevel } from '../../../models/logLevel';
-import { ServerLogService } from '../../services/log-service';
-import { TuerPosition } from './TuerPosition';
-import { SonosService } from '../../services/Sonos/sonos-service';
-import { TelegramService } from '../../services/Telegram/telegram-service';
-import { Utils } from '../../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,
-      );
-    }
-  }
-}
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { LogLevel } from '../../../models/logLevel';
+import { ServerLogService } from '../../services/log-service';
+import { TuerPosition } from './TuerPosition';
+import { SonosService } from '../../services/Sonos/sonos-service';
+import { TelegramService } from '../../services/Telegram/telegram-service';
+import { Utils } from '../../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

@@ -1,55 +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;
-    }
-  }
-}
+import { HmIPDevice } from './hmIpDevice';
+import { HmIpDeviceType } from './hmIpDeviceType';
+import { DeviceInfo } from '../DeviceInfo';
+import { Taste } from '../taste';
+import { LogLevel } from '../../../models/logLevel';
+import { ServerLogService } from '../../services/log-service';
+
+export class HmIpWippe extends HmIPDevice {
+  public tasten: {
+    Unten: Taste;
+    Oben: Taste;
+  } = {
+    Unten: new Taste(1),
+    Oben: new Taste(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: Taste | 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

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

package/server/devices/iIoBrokerDevice.ts

@@ -1,44 +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;
-}
+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/iTaster.ts

@@ -0,0 +1,6 @@
+import { Taste } from "/server/config/private/server/devices/taste";
+
+export interface iTaster {
+  tasten: {[id: string]: Taste};
+  getTastenAssignment(): string;
+}

package/server/devices/{hmIPDevices/hmIpTaste.ts → taste.ts}

@@ -1,72 +1,84 @@
-import { Utils } from '../../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,
-    );
-  }
-}
+import { Utils } from '../services/utils/utils';
+
+export class Taste {
+  public shortPressed: boolean = false;
+  public longPressed: boolean = false;
+  private _shortCallback: Array<{cb: (pValue: boolean) => void, description: string}> = [];
+  private _longCallback: Array<{cb: (pValue: boolean) => void, description: string}> = [];
+  private _shortResetTimeout: null | NodeJS.Timeout = null;
+  private _longResetTimeout: null | NodeJS.Timeout = null;
+
+  public constructor(public updateIndex: number) {}
+
+  public addShortCallback(pCallback: (pValue: boolean) => void, description: string = "Not described") : void {
+    this._shortCallback.push({cb: pCallback, description: description});
+  }
+
+  public addLongCallback(pCallback: (pValue: boolean) => void, description: string = "Not described"): void {
+    this._longCallback.push({cb: pCallback, description: description});
+  }
+
+
+  public getDescription(): string {
+    const description: string[] = [];
+    for (const c of this._shortCallback) {
+      description.push(`Short Press: "${c.description}"`)
+    }
+    for (const c of this._longCallback) {
+      description.push(`Long Press: "${c.description}"`)
+    }
+    return description.join('\n');
+  }
+
+  public updateShort(pValue: boolean): void {
+    if (pValue === this.shortPressed) {
+      return;
+    }
+
+    this.shortPressed = pValue;
+
+    for (const c of this._shortCallback) {
+      c.cb(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.cb(pValue);
+    }
+
+    if (!pValue) {
+      return;
+    }
+
+    this._longResetTimeout !== null && clearTimeout(this._longResetTimeout);
+
+    this._longResetTimeout = Utils.guardedTimeout(
+      () => {
+        this.updateLong(false);
+      },
+      5000,
+      this,
+    );
+  }
+}