hoffmation-base 0.0.1

package/server/devices/hmIPDevices/hmIpGriff.ts

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

package/server/devices/hmIPDevices/hmIpHeizgruppe.ts

@@ -0,0 +1,172 @@
+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 { TemperaturSettings } from '/models/temperaturSettings';
+import { Persist } from '/server/services/dbo/persist';
+import { HmIpHeizung } from './hmIpHeizung';
+import { Devices } from '../devices';
+import { Utils } from '/server/services/utils/utils';
+
+export class HmIpHeizgruppe extends HmIPDevice {
+  private _automaticMode: boolean = true;
+  private _iAutomaticInterval: NodeJS.Timeout;
+  private _level: number = 0;
+  private _temperatur: number = 0;
+  private _humidity: number = 0;
+  private _desiredTemperatur: number = 0;
+  private _setPointTemperaturID: string = '';
+  private _automaticFallBackTemperatur: number = 20;
+  private _automaticPoints: { [name: string]: TemperaturSettings } = {};
+  private _humidityCallbacks: Array<(pValue: number) => void> = [];
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpHeizgruppe);
+    this._setPointTemperaturID = `${this.info.fullID}.1.SET_POINT_TEMPERATURE`;
+    this._iAutomaticInterval = Utils.guardedInterval(this.checkAutomaticChange, 300000, this); // Alle 5 Minuten prüfen
+  }
+
+  public get sLevel(): string {
+    return `${this._level * 100}%`;
+  }
+
+  public get iLevel(): number {
+    return this._level;
+  }
+
+  public get sTemperatur(): string {
+    return `${this._temperatur}°C`;
+  }
+
+  public get iTemperatur(): number {
+    return this._temperatur;
+  }
+
+  public get desiredTemperatur(): number {
+    return this._desiredTemperatur;
+  }
+
+  public get humidity(): number {
+    return this._humidity;
+  }
+
+  private set humidity(val: number) {
+    this._humidity = val;
+    for (const cb of this._humidityCallbacks) {
+      cb(val);
+    }
+  }
+
+  public set desiredTemperatur(val: number) {
+    if (!this.ioConn) {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Connection für "${this.info.customName}" bekannt.`);
+      return;
+    }
+
+    ServerLogService.writeLog(LogLevel.Info, `Neue Temperatur (${val}) für "${this.info.customName}".`);
+    this.ioConn.setState(this._setPointTemperaturID, val, (err) => {
+      if (err) {
+        ServerLogService.writeLog(
+          LogLevel.Error,
+          `Temperaturänderung für "${this.info.customName}" ergab Fehler ${err}.`,
+        );
+      } else {
+        ServerLogService.writeLog(
+          LogLevel.Debug,
+          `Temperaturänderung für "${this.info.customName}" auf ${val} erfolgreich`,
+        );
+      }
+    });
+  }
+
+  public addHumidityCallback(pCallback: (pValue: number) => void): void {
+    this._humidityCallbacks.push(pCallback);
+    if (this._humidity > 0) {
+      pCallback(this._humidity);
+    }
+  }
+
+  public deleteAutomaticPoint(name: string): void {
+    if (this._automaticPoints[name] !== undefined) delete this._automaticPoints[name];
+  }
+
+  public getBelongingHeizungen(): HmIpHeizung[] {
+    const result: HmIpHeizung[] = [];
+    for (const dID in Devices.hmIP) {
+      const d = Devices.hmIP[dID];
+      if (d.deviceType === HmIpDeviceType.HmIpHeizung && d.info.room === this.info.room) {
+        result.push(d as HmIpHeizung);
+      }
+    }
+    return result;
+  }
+
+  public setAutomaticPoint(name: string, setting: TemperaturSettings): void {
+    this._automaticPoints[name] = setting;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.Trace,
+      `Heizgruppe "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
+    );
+    super.update(idSplit, state, initial, true);
+
+    switch (idSplit[3]) {
+      case '1':
+        this.updateBaseInformation(idSplit[4], state, initial);
+        break;
+    }
+  }
+
+  private updateBaseInformation(name: string, state: ioBroker.State, initial: boolean) {
+    switch (name) {
+      case 'ACTUAL_TEMPERATURE':
+        this._temperatur = state.val as number;
+        break;
+      case 'LEVEL':
+        this._level = state.val as number;
+        break;
+      case 'HUMIDITY':
+        this.humidity = state.val as number;
+        break;
+      case 'SET_POINT_TEMPERATURE':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Heizgruppe "${this.info.customName}" Update Soll-Temperatur JSON: ${JSON.stringify(state)}`,
+        );
+        this._desiredTemperatur = state.val as number;
+        break;
+    }
+  }
+
+  private checkAutomaticChange(): void {
+    if (!this._automaticMode) {
+      Persist.addTemperaturDataPoint(this);
+      return;
+    }
+
+    for (const name in this._automaticPoints) {
+      if (this._automaticPoints[name] === undefined) {
+        continue;
+      }
+
+      const settings: TemperaturSettings = this._automaticPoints[name];
+      if (!settings.isNowInRange()) {
+        continue;
+      }
+
+      if (this._desiredTemperatur !== settings.temperatur) {
+        ServerLogService.writeLog(
+          LogLevel.Debug,
+          `Automatische Temperaturanpassung für ${this.info.customName} auf ${settings.temperatur}°C`,
+        );
+        this.desiredTemperatur = settings.temperatur;
+      }
+      break;
+    }
+
+    Persist.addTemperaturDataPoint(this);
+  }
+}

package/server/devices/hmIPDevices/hmIpHeizung.ts

@@ -0,0 +1,69 @@
+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 HmIpHeizung extends HmIPDevice {
+  private _temperatur: number = 0;
+  private _level: number = 0;
+  private _adaptionState: number | undefined;
+  private _desiredTemperatur: number = 0;
+
+  public get desiredTemperatur(): number {
+    return this._desiredTemperatur;
+  }
+
+  public get iLevel(): number {
+    return this._level;
+  }
+
+  public get iTemperatur(): number {
+    return this._temperatur;
+  }
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpHeizung);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.Trace,
+      `Heizung "${this.info.customName}" Update: ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
+    );
+    super.update(idSplit, state, initial, true);
+
+    switch (idSplit[3]) {
+      case '1':
+        this.updateBaseInformation(idSplit[4], state, initial);
+        break;
+    }
+  }
+
+  private updateBaseInformation(name: string, state: ioBroker.State, initial: boolean) {
+    switch (name) {
+      case 'ACTUAL_TEMPERATURE':
+        this._temperatur = state.val as number;
+        break;
+      case 'LEVEL':
+        this._level = state.val as number;
+        break;
+      case 'VALVE_STATE':
+        this._adaptionState = state.val as number;
+        if (this._adaptionState !== 4) {
+          ServerLogService.writeLog(
+            LogLevel.Alert,
+            `Adaption State für Heizung "${this.info.customName}" ungewöhnlich: ${this._adaptionState}`,
+          );
+        }
+        break;
+      case 'SET_POINT_TEMPERATURE':
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Heizung "${this.info.customName}" Update Soll-Temperatur JSON: ${JSON.stringify(state)}`,
+        );
+        this._desiredTemperatur = state.val as number;
+        break;
+    }
+  }
+}

package/server/devices/hmIPDevices/hmIpLampe.ts

@@ -0,0 +1,119 @@
+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 { LampSettings } from '/models/lampSettings';
+import { Utils } from '/server/services/utils/utils';
+
+export class HmIpLampe extends HmIPDevice {
+  public lightOn: boolean | undefined = undefined;
+  public queuedLightValue: boolean | null = null;
+  public isStromStoss: boolean = false;
+  public settings: LampSettings = new LampSettings();
+  private lightOnSwitchID: string = '';
+  private turnOffTimeout: NodeJS.Timeout | undefined = undefined;
+  private turnOffTime: number = 0;
+
+  public constructor(pInfo: DeviceInfo) {
+    super(pInfo, HmIpDeviceType.HmIpLampe);
+    this.lightOnSwitchID = `${this.info.fullID}.2.STATE`;
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(
+      LogLevel.DeepTrace,
+      `Lampen Update für "${this.info.customName}": ID: ${idSplit.join('.')} JSON: ${JSON.stringify(state)}`,
+    );
+    super.update(idSplit, state, initial, true);
+    this.queuedLightValue = null;
+    switch (idSplit[3]) {
+      case '1':
+        if (idSplit[4] === 'STATE') {
+          this.lightOn = state.val as boolean;
+        }
+        break;
+    }
+  }
+
+  /**
+   * This function thats the light to a specific value
+   * @param pValue The desired value
+   * @param timeout A chosen Timeout after which the light should be reset
+   */
+  public setLight(pValue: boolean, timeout: number = -1, force: boolean = false): void {
+    if (!force && pValue === this.lightOn && this.queuedLightValue === null) {
+      ServerLogService.writeLog(
+        LogLevel.DeepTrace,
+        `Skip light command for "${this.info.customName}" as it is already ${pValue}`,
+      );
+      return;
+    }
+    if (this.lightOnSwitchID === '') {
+      ServerLogService.writeLog(LogLevel.Error, `Keine Switch 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 (!force && Utils.nowMS() < this.turnOffTime) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Skip automatic command for "${this.info.customName}" to ${pValue} as it is locked until ${new Date(
+          this.turnOffTime,
+        ).toLocaleString()}`,
+      );
+      return;
+    }
+
+    ServerLogService.writeLog(LogLevel.Debug, `Lampe schalten: "${this.info.customName}" Wert: ${pValue}`);
+    this.ioConn.setState(this.lightOnSwitchID, pValue, (err) => {
+      if (err) {
+        ServerLogService.writeLog(LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
+      }
+    });
+    this.queuedLightValue = pValue;
+
+    if (this.isStromStoss) {
+      timeout = 5000;
+    }
+
+    if (this.turnOffTimeout !== undefined) {
+      clearTimeout(this.turnOffTimeout);
+      this.turnOffTimeout = undefined;
+    }
+
+    if (timeout < 0 || !pValue) {
+      return;
+    }
+
+    this.turnOffTime = Utils.nowMS() + timeout;
+    this.turnOffTimeout = Utils.guardedTimeout(
+      () => {
+        ServerLogService.writeLog(LogLevel.Debug, `Delayed Turnoff for "${this.info.customName}" initiated`);
+        this.turnOffTimeout = undefined;
+        if (!this.room) {
+          this.setLight(false, -1, true);
+        } else {
+          this.room.setLightTimeBased(true);
+        }
+      },
+      timeout,
+      this,
+    );
+  }
+
+  /**
+   * Switch the current condition of the light
+   * @param force Whether this is a forcing action skipping delays and locks
+   */
+  public toggleLight(force: boolean = false): boolean {
+    const newVal = this.queuedLightValue !== null ? !this.queuedLightValue : !this.lightOn;
+    const timeout: number = newVal && force ? 30 * 60 * 1000 : -1;
+    this.setLight(newVal, timeout, force);
+    return newVal;
+  }
+}

package/server/devices/hmIPDevices/hmIpPraezenz.ts

@@ -0,0 +1,99 @@
+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 { Persist } from '/server/services/dbo/persist';
+import { CountToday } from '../../../models/persistence/todaysCount';
+import { Utils } from '/server/services/utils/utils';
+
+export class HmIpPraezenz extends HmIPDevice {
+  public excludeFromNightAlarm: boolean = false;
+  public presenceDetected: boolean = false;
+  private _detectionsToday: number = 0;
+  private _presenceDetectedCallback: Array<(pValue: boolean) => void> = [];
+  private static PRESENCE_DETECTION: string = 'PRESENCE_DETECTION_STATE';
+  private presenceStateID: string;
+  private initialized: boolean = 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.HmIpPraezenz);
+    this.presenceStateID = `${this.info.fullID}.1.${HmIpPraezenz.PRESENCE_DETECTION}`;
+    Persist.getCount(this).then((todayCount: CountToday) => {
+      this.detectionsToday = todayCount.counter;
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Präsenzcounter "${this.info.customName}" vorinitialisiert mit ${this.detectionsToday}`,
+      );
+      this.initialized = true;
+    });
+  }
+
+  public addPresenceCallback(pCallback: (pValue: boolean) => void): void {
+    this._presenceDetectedCallback.push(pCallback);
+  }
+
+  public update(idSplit: string[], state: ioBroker.State, initial: boolean = false): void {
+    ServerLogService.writeLog(LogLevel.Trace, `Präzens Update: JSON: ${JSON.stringify(state)}ID: ${idSplit.join('.')}`);
+    super.update(idSplit, state, initial, true);
+
+    if (idSplit[3] !== '1') {
+      // Nur die Infos in Kanal 1 sind relevant
+      return;
+    }
+
+    switch (idSplit[4]) {
+      case HmIpPraezenz.PRESENCE_DETECTION:
+        this.updatePresence(state.val as boolean);
+        break;
+    }
+  }
+
+  public updatePresence(pVal: boolean): void {
+    if (!this.initialized && pVal) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Präsenz für "${this.info.customName}" erkannt aber die Initialisierung aus der DB ist noch nicht erfolgt --> verzögern`,
+      );
+      Utils.guardedTimeout(
+        () => {
+          this.updatePresence(pVal);
+        },
+        1000,
+        this,
+      );
+      return;
+    }
+    if (pVal === this.presenceDetected) {
+      ServerLogService.writeLog(
+        LogLevel.Debug,
+        `Überspringe Präsenz für "${this.info.customName}" da bereits der Wert ${pVal} vorliegt`,
+      );
+      return;
+    }
+
+    this.presenceDetected = pVal;
+    ServerLogService.writeLog(LogLevel.Debug, `Neuer Präsenzstatus Wert für "${this.info.customName}": ${pVal}`);
+
+    if (pVal) {
+      this.detectionsToday++;
+      ServerLogService.writeLog(
+        LogLevel.Trace,
+        `Dies ist die ${this.detectionsToday} Bewegung für "${this.info.customName}"`,
+      );
+    }
+    for (const c of this._presenceDetectedCallback) {
+      c(pVal);
+    }
+  }
+}