hoffmation-base 0.0.1

package/server/devices/Heizgruppen.ts

@@ -0,0 +1,91 @@
+import { Persist } from '../services/dbo/persist';
+import { Devices } from './devices';
+import { HmIpDeviceType } from './hmIPDevices/hmIpDeviceType';
+import { HmIpHeizgruppe } from './hmIPDevices/hmIpHeizgruppe';
+import { HmIpHeizung } from './hmIPDevices/hmIpHeizung';
+import { TemperaturDataPoint } from '/models/persistence/temperaturDataPoint';
+
+export class Heizgruppen {
+  public static getInfo(): string {
+    const gruppen: HmIpHeizgruppe[] = Heizgruppen.getAllGruppen();
+    gruppen.sort((a, b): number => {
+      return a.info.customName.localeCompare(b.info.customName);
+    });
+
+    const response: string[] = [`Dies sind die aktuellen Informationen der Heizungen:`];
+    response.push(`Name\t\tLuft Feuchtigkeit\t\tAktuelle Temperatur\t\tSoll Temperatur\t\tVentilstellung`);
+    for (const g of gruppen) {
+      response.push(
+        `${g.info.customName}:\t\t${g.humidity}%\t\t${g.sTemperatur}\t\t${g.desiredTemperatur}°C\t\t${g.sLevel}`,
+      );
+    }
+    return response.join('\n');
+  }
+
+  public static async getSpecificInfo(pText: string | undefined): Promise<string> {
+    if (pText === undefined || !pText.includes('"')) {
+      return `Bitte übergeben Sie eine Heizgruppe innerhalb von "". z.B. "EG Flur HeizGr"`;
+    }
+    const searchText = pText.split('"')[1];
+    const group: HmIpHeizgruppe | undefined = this.getSpecificGroup(searchText);
+
+    if (group === undefined) {
+      return `"${searchText}" ist keine gültige Heizgruppe, im Folgenden ist eine Liste aller gültigen Heizgruppen:\n${this.getInfo()}`;
+    }
+
+    const results: TemperaturDataPoint[] = await Persist.readTemperaturDataPoint(group, 20);
+    const response: string[] = [`Dies sind die letzten 20 Messpunkte der Heizgruppe:`];
+    response.push(`Zeitpunkt\t\tIst-Temperatur\t\tSoll-Temperatur\t\tVentilstellung`);
+    for (const r of results) {
+      response.push(
+        `${r.date.toLocaleTimeString('de-DE')}:\t\t${r.istTemperatur}°C\t\t${r.sollTemperatur}°C\t\t${r.level}%`,
+      );
+    }
+    return response.join('\n');
+  }
+
+  public static getProblems(): string {
+    const groups: HmIpHeizgruppe[] = this.getAllGruppen();
+
+    const response: string[] = [`Dies sind die bestehenden Differenzen:`];
+    response.push(`Raumname\t\tIst-Temperatur\t\tGerät`);
+    for (const g of groups) {
+      const heizungen: HmIpHeizung[] = g.getBelongingHeizungen();
+      const tempProblem: string[] = [`${g.info.room}\t\t${g.iTemperatur}°C\t\t${g.info.customName}`];
+      let print = false;
+      for (const h of heizungen) {
+        if (h.iTemperatur !== g.iTemperatur) {
+          print = true;
+        }
+        tempProblem.push(`${h.info.room}\t\t${h.iTemperatur}°C\t\t${h.info.customName}`);
+      }
+      if (print) {
+        response.push(tempProblem.join('\n'));
+        response.push(' ');
+      }
+    }
+    return response.join('\n');
+  }
+
+  public static getAllGruppen(): HmIpHeizgruppe[] {
+    const gruppen: HmIpHeizgruppe[] = [];
+    for (const dID in Devices.hmIP) {
+      const d = Devices.hmIP[dID];
+      if (d.deviceType === HmIpDeviceType.HmIpHeizgruppe) {
+        gruppen.push(d as HmIpHeizgruppe);
+      }
+    }
+    return gruppen;
+  }
+
+  public static getSpecificGroup(name: string): HmIpHeizgruppe | undefined {
+    for (const dID in Devices.hmIP) {
+      const d = Devices.hmIP[dID];
+      if (d.deviceType === HmIpDeviceType.HmIpHeizgruppe && d.info.customName === name) {
+        return d as HmIpHeizgruppe;
+      }
+    }
+
+    return undefined;
+  }
+}

package/server/devices/Rollos.ts

@@ -0,0 +1,48 @@
+import { Devices } from './devices';
+import { HmIpDeviceType } from './hmIPDevices/hmIpDeviceType';
+import { HmIpRoll } from './hmIPDevices/hmIpRoll';
+import { RoomBase } from '/models/rooms/RoomBase';
+
+export class Rolladen {
+  public static getRolladenPosition(): string {
+    const rollos: HmIpRoll[] = Rolladen.getAllRollos();
+    rollos.sort((a, b): number => {
+      return b.currentLevel - a.currentLevel;
+    });
+
+    const response: string[] = [`Dies sind die aktuellen Rollo Positionen:`];
+    for (const r of rollos) {
+      response.push(`${r.currentLevel}% Rollo: "${r.info.customName}" Gewünschte Position: ${r.desiredFensterLevel}`);
+    }
+    response.push(`\nDie nächsten Zeiten zum Hochfahren:`);
+    const down: string[] = [`\nDie nächsten Zeiten zum Runterfahren:`];
+    const rooms: RoomBase[] = RoomBase.allRooms;
+    for (const r of rooms) {
+      for (const f of r.FensterGroup.fenster) {
+        if (f.rollo) {
+          response.push(
+            `Rollo: "${f.rollo.info.customName}"\t${
+              f.noRolloOnSunrise ? 'Hochfahren inaktiv' : r.sonnenAufgangCallback?.nextToDo?.toLocaleTimeString()
+            }`,
+          );
+          down.push(
+            `Rollo: "${f.rollo.info.customName}"\t${r.sonnenUntergangCallback?.nextToDo?.toLocaleTimeString()}`,
+          );
+        }
+      }
+    }
+    response.push(down.join('\n'));
+    return response.join('\n');
+  }
+
+  public static getAllRollos(): HmIpRoll[] {
+    const rollos: HmIpRoll[] = [];
+    for (const dID in Devices.hmIP) {
+      const d = Devices.hmIP[dID];
+      if (d.deviceType === HmIpDeviceType.HmIpRoll) {
+        rollos.push(d as HmIpRoll);
+      }
+    }
+    return rollos;
+  }
+}

package/server/devices/deviceUpdater.ts

@@ -0,0 +1,72 @@
+import { ServerLogService } from '../services/log-service';
+import { Devices } from './devices';
+import { HmIPDevice } from './hmIPDevices/hmIpDevice';
+import { IDeviceUpdater } from './iDeviceUpdater';
+import { ZigbeeDevice } from './zigbee/zigbeeDevice';
+import { LogLevel } from '/models/logLevel';
+
+export class DeviceUpdater implements IDeviceUpdater {
+  private static IDENTIFIER_HOMEMATIC: string = 'hm-rpc';
+  private static IDENTIFIER_ZIGBEE: string = 'zigbee';
+  public devices: Devices;
+
+  constructor(pDevices: Devices) {
+    this.devices = pDevices;
+  }
+
+  public updateObject(pId: string, pObj: ioBroker.Object): void {
+    const idSplit: string[] = pId.split('.');
+    if (idSplit.length < 2) return;
+
+    if (idSplit[0] === DeviceUpdater.IDENTIFIER_HOMEMATIC) {
+      console.log(`Neuer Wert in HomematicIP für ${pId}: ${JSON.stringify(pObj)}`);
+    }
+  }
+
+  public updateState(id: string, state: ioBroker.State, initial: boolean = false): void {
+    if (state === null) {
+      // Ignore null states
+      return;
+    }
+    const idSplit: string[] = id.split('.');
+    if (idSplit.length < 2) return;
+
+    if (idSplit[0] === DeviceUpdater.IDENTIFIER_HOMEMATIC) {
+      try {
+        this.updateHomeMaticDevice(idSplit, state, initial);
+      } catch (e: any) {
+        ServerLogService.writeLog(
+          LogLevel.Alert,
+          `deviceUpdater.updateState('${id}', '${state}'): Error occured updating Device: ${e} \n ${e.stack}`,
+        );
+      }
+    } else if (idSplit[0] === DeviceUpdater.IDENTIFIER_ZIGBEE) {
+      try {
+        this.updateZigbeeDevice(idSplit, state, initial);
+      } catch (e: any) {
+        ServerLogService.writeLog(
+          LogLevel.Alert,
+          `deviceUpdater.updateState('${id}', '${state}'): Error occured updating Device: ${e} \n ${e.stack}`,
+        );
+      }
+    } else {
+      ServerLogService.writeLog(LogLevel.DeepTrace, `unbekannter Identifier: "${idSplit[0]}"`);
+    }
+  }
+
+  private updateHomeMaticDevice(idSplit: string[], state: ioBroker.State, initial: boolean = false) {
+    const device: undefined | HmIPDevice = Devices.hmIP[idSplit[2]];
+    if (typeof device === 'undefined') {
+      return;
+    }
+    device.update(idSplit, state, initial);
+  }
+
+  private updateZigbeeDevice(idSplit: string[], state: ioBroker.State, initial: boolean = false) {
+    const device: undefined | ZigbeeDevice = Devices.Zigbee[idSplit[2]];
+    if (typeof device === 'undefined') {
+      return;
+    }
+    device.update(idSplit, state, initial);
+  }
+}

package/server/devices/devices.ts

@@ -0,0 +1,189 @@
+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 { LogLevel } from '/models/logLevel';
+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 '/server/devices/zigbee/zigbeeHeimanSmoke';
+import { ZigbeeAquaraWater } from '/server/devices/zigbee/zigbeeAquaraWater';
+import { ZigbeeBlitzShp } from '/server/devices/zigbee/zigbeeBlitzShp';
+import { ZigbeeIlluLampe } from '/server/devices/zigbee/zigbeeIlluLampe';
+import { ZigbeeIlluActuator } from '/server/devices/zigbee/zigbeeIlluActuator';
+import { iRoomImportEnforcer } from '/models/rooms/iRoomImportEnforcer';
+
+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 '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

@@ -0,0 +1,175 @@
+import { Fenster } from '../hmIPDevices/Fenster';
+import { FensterPosition } from '../hmIPDevices/FensterPosition';
+import { ServerLogService } from '../../services/log-service';
+import { LogLevel } from '../../../models/logLevel';
+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

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

@@ -0,0 +1,88 @@
+import { HmIpLampe } from '../hmIPDevices/hmIpLampe';
+import { ZigbeeIkeaSteckdose } from '../zigbee/zigbeeIkeaSteckdose';
+import { ZigbeeIlluDimmer } from '../zigbee/zigbeeIlluDimmer';
+import { ZigbeeIlluLedRGBCCT } from '../zigbee/zigbeeIlluLedRGBCCT';
+import { TimeCallbackService, TimeOfDay } from '../../services/time-callback-service';
+import { RoomBase } from '../../../models/rooms/RoomBase';
+import { ZigbeeIlluLampe } from '../zigbee/zigbeeIlluLampe';
+
+export class LampenGroup {
+  public constructor(
+    private _room: RoomBase,
+    public Lampen: Array<HmIpLampe | ZigbeeIlluDimmer | ZigbeeIlluLampe>,
+    public Stecker: Array<ZigbeeIkeaSteckdose>,
+    public LED: Array<ZigbeeIlluLedRGBCCT> = [],
+  ) {
+    for (const lamp of [...Lampen, ...Stecker, ...LED]) {
+      lamp.room = this._room;
+    }
+  }
+
+  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);
+    });
+  }
+}