hoffmation-base 0.1.14 → 0.1.18

package/server/devices/devices.ts

@@ -1,193 +0,0 @@
-import { LogLevel } from '../../models/logLevel';
-import { HmIpDeviceType } from './hmIPDevices/hmIpDeviceType';
-import { ZigbeeDeviceType } from './zigbee/zigbeeDeviceType';
-import { IOBrokerConnection } from '../ioBroker/connection';
-import { ServerLogService } from '../services/log-service';
-import { HmIPDevice } from './hmIPDevices/hmIpDevice';
-import { ZigbeeDevice } from './zigbee/zigbeeDevice';
-import { HmIpGriff } from './hmIPDevices/hmIpGriff';
-import { HmIpHeizung } from './hmIPDevices/hmIpHeizung';
-import { DeviceInfo } from './DeviceInfo';
-import { HmIpLampe } from './hmIPDevices/hmIpLampe';
-import { HmIpPraezenz } from './hmIPDevices/hmIpPraezenz';
-import { HmIpRoll } from './hmIPDevices/hmIpRoll';
-import { HmIpTaster } from './hmIPDevices/hmIpTaster';
-import { HmIpTherm } from './hmIPDevices/hmIpTherm';
-import { HmIpTuer } from './hmIPDevices/hmIpTuer';
-import { HmIpWippe } from './hmIPDevices/hmIpWippe';
-import { deviceConfig } from '../../models/deviceConfig';
-import { HmIpHeizgruppe } from './hmIPDevices/hmIpHeizgruppe';
-import { HmIpBewegung } from './hmIPDevices/hmIpBewegung';
-import { ZigbeeIkeaSteckdose } from './zigbee/zigbeeIkeaSteckdose';
-import { ZigbeeIlluLedRGBCCT } from './zigbee/zigbeeIlluLedRGBCCT';
-import { ZigbeeAquaraVibra } from './zigbee/zigbeeAquaraVibra';
-import { ZigbeeIlluDimmer } from './zigbee/zigbeeIlluDimmer';
-import { ZigbeeHeimanSmoke } from './zigbee/zigbeeHeimanSmoke';
-import { ZigbeeAquaraWater } from './zigbee/zigbeeAquaraWater';
-import { ZigbeeBlitzShp } from './zigbee/zigbeeBlitzShp';
-import { ZigbeeIlluLampe } from './zigbee/zigbeeIlluLampe';
-import { ZigbeeIlluActuator } from './zigbee/zigbeeIlluActuator';
-import { iRoomImportEnforcer } from '../../models/rooms/iRoomImportEnforcer';
-import { ZigbeeAquaraMotion } from './zigbee/zigbeeAquaraMotion';
-
-export class Devices {
-  public static hmIP: { [id: string]: HmIPDevice } = {};
-  public static Zigbee: { [id: string]: ZigbeeDevice } = {};
-
-  public constructor(pDeviceData: { [id: string]: deviceConfig }, pRoomImportEnforcer: iRoomImportEnforcer) {
-    // This forces import of rooms at correct timing, to allow devices to land in proper rooms.
-    pRoomImportEnforcer.addRoomConstructor();
-
-    for (const cID in pDeviceData) {
-      const cDevConf: deviceConfig = pDeviceData[cID];
-      if (
-        !cDevConf.common ||
-        !cDevConf.common.name ||
-        typeof cDevConf.common.name === 'object' ||
-        !cDevConf.type ||
-        cDevConf.type === 'channel'
-      ) {
-        continue;
-      }
-
-      const cName: string = cDevConf.common.name;
-
-      if (cName.indexOf('00-HmIP') === 0) {
-        this.processHMIPDevice(cDevConf);
-      } else if (cName.indexOf('00-Zigbee') === 0) {
-        this.processZigbeeDevice(cDevConf);
-      }
-    }
-
-    HmIPDevice.checkMissing();
-    ZigbeeDevice.checkMissing();
-  }
-
-  public static addIoConnection(pIoConnection: IOBrokerConnection): void {
-    for (const id in Devices.hmIP) {
-      Devices.hmIP[id].ioConn = pIoConnection;
-    }
-
-    for (const id in Devices.Zigbee) {
-      Devices.Zigbee[id].ioConn = pIoConnection;
-    }
-  }
-
-  public static midnightReset(): void {
-    // Nothing yet
-  }
-
-  public static resetPraesenzCount(): void {
-    ServerLogService.writeLog(LogLevel.Info, `3 Uhr Reset der Präsenzmelder`);
-    for (const dID in Devices.hmIP) {
-      const d = Devices.hmIP[dID];
-      if (d.deviceType === HmIpDeviceType.HmIpPraezenz) {
-        ServerLogService.writeLog(LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
-        (d as HmIpPraezenz).detectionsToday = 0;
-      } else if (d.deviceType === HmIpDeviceType.HmIpBewegung) {
-        ServerLogService.writeLog(LogLevel.Debug, `2 Uhr Reset der Tages Detektionen von ${d.info.customName}`);
-        (d as HmIpBewegung).detectionsToday = 0;
-      }
-    }
-  }
-
-  private processZigbeeDevice(cDevConf: deviceConfig) {
-    const zigbeeInfo: DeviceInfo = new DeviceInfo(cDevConf);
-
-    if (typeof Devices.Zigbee[zigbeeInfo.devID] !== 'undefined') {
-      return;
-    }
-
-    ServerLogService.writeLog(
-      LogLevel.Trace,
-      `${zigbeeInfo.devID} with Type "${zigbeeInfo.deviceType}" doesn't exists --> create it`,
-    );
-
-    switch (zigbeeInfo.deviceType) {
-      case 'AquaraVibra':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeAquaraVibra(zigbeeInfo);
-        break;
-      case 'AquaraMotion':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeAquaraMotion(zigbeeInfo);
-        break;
-      case 'IkeaStecker':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeIkeaSteckdose(zigbeeInfo);
-        break;
-      case 'LedRGBCCT':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeIlluLedRGBCCT(zigbeeInfo);
-        break;
-      case 'IlluDimmer':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeIlluDimmer(zigbeeInfo);
-        break;
-      case 'HeimanSmoke':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeHeimanSmoke(zigbeeInfo);
-        break;
-      case 'AquaraWater':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeAquaraWater(zigbeeInfo);
-        break;
-      case 'BlitzShp':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeBlitzShp(zigbeeInfo);
-        break;
-      case 'IlluLampe':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeIlluLampe(zigbeeInfo);
-        break;
-      case 'IlluActuator':
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeIlluActuator(zigbeeInfo);
-        break;
-      default:
-        ServerLogService.writeLog(LogLevel.Warn, `No zigbee Device Type for ${zigbeeInfo.deviceType} defined`);
-        Devices.Zigbee[zigbeeInfo.devID] = new ZigbeeDevice(zigbeeInfo, ZigbeeDeviceType.unknown);
-    }
-  }
-
-  private processHMIPDevice(cDevConf: deviceConfig) {
-    const hmIPInfo: DeviceInfo = new DeviceInfo(cDevConf);
-
-    if (typeof Devices.hmIP[hmIPInfo.devID] !== 'undefined') {
-      return;
-    }
-    ServerLogService.writeLog(
-      LogLevel.Trace,
-      `${hmIPInfo.devID} with Type "${hmIPInfo.deviceType}" doesn't exists --> create it`,
-    );
-    switch (hmIPInfo.deviceType) {
-      case 'Lampe':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpLampe(hmIPInfo);
-        break;
-      case 'Roll':
-      case 'Broll':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpRoll(hmIPInfo);
-        break;
-      case 'Beweg':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpBewegung(hmIPInfo);
-        break;
-      case 'Taster':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpTaster(hmIPInfo);
-        break;
-      case 'Wippe':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpWippe(hmIPInfo);
-        break;
-      case 'Praezenz':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpPraezenz(hmIPInfo);
-        break;
-      case 'Griff':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpGriff(hmIPInfo);
-        break;
-      case 'Thermostat':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpTherm(hmIPInfo);
-        break;
-      case 'Heizung':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpHeizung(hmIPInfo);
-        break;
-      case 'Tuer':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpTuer(hmIPInfo);
-        break;
-      case 'HeizGr':
-        Devices.hmIP[hmIPInfo.devID] = new HmIpHeizgruppe(hmIPInfo);
-        break;
-      default:
-        ServerLogService.writeLog(LogLevel.Warn, `No HmIP Device Type for ${hmIPInfo.deviceType} defined`);
-        Devices.hmIP[hmIPInfo.devID] = new HmIPDevice(hmIPInfo, HmIpDeviceType.unknown);
-    }
-  }
-}

package/server/devices/groups/fensterGroup.ts

@@ -1,175 +0,0 @@
-import { LogLevel } from '../../../models/logLevel';
-import { Fenster } from '../hmIPDevices/Fenster';
-import { FensterPosition } from '../hmIPDevices/FensterPosition';
-import { ServerLogService } from '../../services/log-service';
-import { RoomBase } from '../../../models/rooms/RoomBase';
-import { TimeCallback, TimeCallbackType } from '../../../models/timeCallback';
-import { TimeCallbackService, TimeOfDay } from '../../services/time-callback-service';
-import { Utils } from '../../services/utils/utils';
-import { WeatherService } from '../../services/weather/weather-service';
-
-export class FensterGroup {
-  public constructor(private _room: RoomBase, public fenster: Fenster[]) {
-    for (const f of [...fenster]) {
-      f.room = this._room;
-    }
-  }
-
-  public allRolloDown(initial: boolean = false, savePosition: boolean = false): void {
-    this.fenster.forEach((f) => {
-      if (savePosition) f.desiredPosition = 0;
-      if (f.rollo !== undefined) {
-        ServerLogService.writeLog(
-          LogLevel.Debug,
-          `Fahre das Rollo zum Sonnenuntergang ${initial ? '(ggf. nachträglich) ' : ''}für ${
-            f.rollo.info.customName
-          } runter`,
-        );
-        f.rollo.down(initial);
-      }
-    });
-  }
-
-  public allRolloUp(savePosition: boolean = false): void {
-    this.fenster.forEach((f) => {
-      if (f.rollo === undefined) {
-        return;
-      }
-
-      if (savePosition) {
-        f.desiredPosition = 100;
-      }
-      f.rollo.up(false);
-    });
-  }
-
-  public allRolloToLevel(level: number, savePosition: boolean = false): void {
-    this.fenster.forEach((f) => {
-      if (savePosition) {
-        f.desiredPosition = level;
-      }
-      if (f.rollo !== undefined) {
-        f.rollo.setLevel(level, false);
-      }
-    });
-  }
-
-  public initCallbacks(): void {
-    if (this._room.Einstellungen.sonnenAufgangRollos && this._room.Einstellungen.rolloOffset) {
-      ServerLogService.writeLog(LogLevel.Trace, `Sonnenaufgang TimeCallback für ${this._room.roomName} hinzufügen`);
-      this._room.sonnenAufgangCallback = new TimeCallback(
-        `${this._room.roomName} Sonnenaufgang Rollos`,
-        TimeCallbackType.Sunrise,
-        () => {
-          if (this._room.skipNextRolloUp) {
-            this._room.skipNextRolloUp = false;
-            return;
-          }
-          this.sunriseUp();
-        },
-        this._room.Einstellungen.rolloOffset.sunrise,
-        undefined,
-        undefined,
-        this._room.Einstellungen.rolloOffset,
-      );
-      if (!TimeCallbackService.darkOutsideOrNight(TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset))) {
-        this.sunriseUp(true);
-      }
-      TimeCallbackService.addCallback(this._room.sonnenAufgangCallback);
-    }
-
-    if (this._room.Einstellungen.sonnenUntergangRollos && this._room.Einstellungen.rolloOffset) {
-      this._room.sonnenUntergangCallback = new TimeCallback(
-        `${this._room.roomName} Sonnenuntergang Rollo`,
-        TimeCallbackType.SunSet,
-        () => {
-          this.sunsetDown();
-        },
-        this._room.Einstellungen.rolloOffset.sunset,
-      );
-      if (TimeCallbackService.darkOutsideOrNight(TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset))) {
-        Utils.guardedTimeout(
-          () => {
-            this.allRolloDown(true, true);
-          },
-          60000,
-          this,
-        );
-      }
-      TimeCallbackService.addCallback(this._room.sonnenUntergangCallback);
-    }
-
-    if (this._room.Einstellungen.rolloHeatReduction) {
-      Utils.guardedInterval(this.setRolloByWeatherStatus, 15 * 60 * 1000, this, true);
-      Utils.guardedTimeout(this.setRolloByWeatherStatus, 2 * 60 * 1000, this);
-    }
-  }
-
-  private sunsetDown(): void {
-    this.allRolloToLevel(0, true);
-    if (this._room.PraesenzGroup.anyPresent() && this._room.Einstellungen.lampOffset) {
-      this._room.LampenGroup.switchTimeConditional(TimeCallbackService.dayType(this._room.Einstellungen.lampOffset));
-    }
-  }
-
-  public setRolloByWeatherStatus(): void {
-    const timeOfDay: TimeOfDay = TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset);
-    const darkOutside: boolean = TimeCallbackService.darkOutsideOrNight(timeOfDay);
-    this.fenster.forEach((f) => {
-      if (!f.rollo) {
-        return;
-      }
-      if (darkOutside) {
-        f.restoreDesiredPosition();
-        return;
-      }
-      let desiredPos: number = f.desiredPosition;
-      if (desiredPos > 0) {
-        WeatherService.weatherRolloPosition(
-          desiredPos,
-          this._room.HeatGroup.desiredTemp,
-          this._room.HeatGroup.currentTemp,
-        );
-      }
-      if (f.griffeInPosition(FensterPosition.offen) > 0 && desiredPos < 100) {
-        return;
-      }
-      if (f.griffeInPosition(FensterPosition.kipp) > 0) {
-        desiredPos = Math.max(30, desiredPos);
-      }
-      if (f.rollo.currentLevel === desiredPos) {
-        // Rollo ist bereits auf der Zielposition
-        return;
-      }
-      f.rollo.setLevel(desiredPos, false, true);
-    });
-  }
-
-  public sunriseUp(initial: boolean = false): void {
-    this.fenster.forEach((f) => {
-      if (!f.noRolloOnSunrise && f.rollo) {
-        ServerLogService.writeLog(
-          LogLevel.Debug,
-          `Fahre das Rollo zum Sonnenaufgang ${initial ? '(ggf. nachträglich)' : ''}für ${
-            f.rollo.info.customName
-          } hoch`,
-        );
-        f.setDesiredPosition(100);
-      }
-    });
-  }
-
-  public restoreRolloPosition(recalc: boolean = false): void {
-    if (!recalc) {
-      this.fenster.forEach((f) => {
-        f.restoreDesiredPosition();
-      });
-      return;
-    }
-    if (!TimeCallbackService.darkOutsideOrNight(TimeCallbackService.dayType(this._room.Einstellungen.rolloOffset))) {
-      this.sunriseUp(true);
-    } else {
-      this.sunsetDown();
-    }
-  }
-}

package/server/devices/groups/heatGroup.ts

@@ -1,32 +0,0 @@
-import { RoomBase } from '../../../models/rooms/RoomBase';
-import { HmIpHeizgruppe } from '../hmIPDevices/hmIpHeizgruppe';
-
-export class HeatGroup {
-  public get currentTemp(): number {
-    if (this.heaters.length === 0) {
-      return -99;
-    }
-    let value: number = 0;
-    for (const h of this.heaters) {
-      value += h.iTemperatur;
-    }
-    return Math.round((value / this.heaters.length) * 10) / 10;
-  }
-
-  public get desiredTemp(): number {
-    if (this.heaters.length === 0) {
-      return -99;
-    }
-    let value: number = 0;
-    for (const h of this.heaters) {
-      value += h.desiredTemperatur;
-    }
-    return Math.round((value / this.heaters.length) * 10) / 10;
-  }
-
-  public constructor(private _room: RoomBase, public heaters: HmIpHeizgruppe[]) {
-    for (const h of [...heaters]) {
-      h.room = this._room;
-    }
-  }
-}

package/server/devices/groups/lampenGroup.ts

@@ -1,106 +0,0 @@
-import { ZigbeeIkeaSteckdose } from '../zigbee/zigbeeIkeaSteckdose';
-import { ZigbeeIlluLedRGBCCT } from '../zigbee/zigbeeIlluLedRGBCCT';
-import { TimeCallbackService, TimeOfDay } from '../../services/time-callback-service';
-import { RoomBase } from '../../../models/rooms/RoomBase';
-import { iLamp } from '../iLamp';
-
-export class LampenGroup {
-  public constructor(
-    private _room: RoomBase,
-    public Lampen: Array<iLamp>,
-    public Stecker: Array<ZigbeeIkeaSteckdose>,
-    public LED: Array<ZigbeeIlluLedRGBCCT> = [],
-  ) {
-    for (const lamp of [...Lampen, ...Stecker, ...LED]) {
-      lamp.room = this._room;
-    }
-  }
-
-  public anyLightsOwn(): boolean {
-    let i: number;
-    for(i=0; i<this.Lampen.length; i++) {
-      if(this.Lampen[i].lightOn) {
-        return true;
-      }
-    }
-    for(i=0; i<this.LED.length; i++) {
-      if(this.LED[i].on) {
-        return true;
-      }
-    }
-    for(i=0; i<this.Stecker.length; i++) {
-      if(this.Stecker[i].steckerOn) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  public switchAll(target: boolean, force: boolean = false): void {
-    this.setAllLampen(target, undefined, force);
-    this.setAllStecker(target, undefined, force);
-
-    this.LED.forEach((s) => {
-      s.setLight(target);
-    });
-  }
-
-  public switchTimeConditional(time: TimeOfDay): void {
-    const darkOutside: boolean = TimeCallbackService.darkOutsideOrNight(time);
-
-    let resultLampen = false;
-    let resultSteckdosen = false;
-    if (this.LED.length > 0) {
-      this.LED.forEach((s) => {
-        s.setTimeBased(time);
-      });
-    } else if (this.Stecker.length > 0) {
-      resultSteckdosen = darkOutside;
-    } else {
-      resultLampen = darkOutside;
-    }
-
-    this.setAllLampen(resultLampen, time);
-    this.setAllStecker(resultSteckdosen, time);
-  }
-
-  public setAllLampen(pValue: boolean, time?: TimeOfDay, force: boolean = false): void {
-    if (this.Lampen?.length > 0) {
-      this.Lampen.forEach((s) => {
-        if (
-          !pValue ||
-          time === undefined ||
-          (time === TimeOfDay.Night && s.settings.nightOn) ||
-          (time === TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
-          (time === TimeOfDay.AfterSunset && s.settings.duskOn)
-        ) {
-          const timeout: number = pValue && force ? 30 * 60 * 1000 : -1;
-          s.setLight(pValue, timeout, force);
-        }
-      });
-    }
-  }
-
-  public setAllStecker(pValue: boolean, time?: TimeOfDay, force: boolean = false): void {
-    if (this.Stecker?.length > 0) {
-      this.Stecker.forEach((s) => {
-        if (
-          !pValue ||
-          time === undefined ||
-          (time === TimeOfDay.Night && s.settings.nightOn) ||
-          (time === TimeOfDay.BeforeSunrise && s.settings.dawnOn) ||
-          (time === TimeOfDay.AfterSunset && s.settings.duskOn)
-        ) {
-          const timeout: number = pValue && force ? 30 * 60 * 1000 : -1;
-          s.setStecker(pValue, timeout, force);
-        }
-      });
-    }
-  }
-
-  public setAllLED(pValue: boolean, brightness: number = -1, color: string = '', colortemp: number = -1): void {
-    this.LED.forEach((s) => {
-      s.setLight(pValue, brightness, color, colortemp);
-    });
-  }
-}

package/server/devices/groups/praesenzGroup.ts

@@ -1,187 +0,0 @@
-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';
-import { ZigbeeAquaraMotion } from '../zigbee/zigbeeAquaraMotion';
-
-export class PraesenzGroup {
-  private _lastMovement: Date = new Date(0);
-
-  public constructor(
-    private _room: RoomBase,
-    public Prasenzen: HmIpPraezenz[],
-    public Bewegungen: HmIpBewegung[] | ZigbeeAquaraMotion[],
-  ) {
-    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);
-      });
-    });
-  }
-}