hoffmation-base 0.0.1

package/models/rooms/RoomSettings/RoomSettings.ts

@@ -0,0 +1,159 @@
+import { HmIpRoomSettings } from './hmIPRoomSettings';
+import { ZigbeeRoomSettings } from './zigbeeRoomSettings';
+import { SettingsService } from '../../../server/services/settings-service';
+import { iRoomDefaultSettings } from './iRoomDefaultSettings';
+import { SunTimeOffsets } from '../../../server/services/time-callback-service';
+
+import { RoomBase } from '../RoomBase';
+import { iTimePair } from '../../../server/config/iConfig';
+
+export class RoomSettings implements iRoomDefaultSettings {
+  public defaultSettings: iRoomDefaultSettings = SettingsService.settings.roomDefault;
+  private _lampenBeiBewegung: boolean = this.defaultSettings.lampenBeiBewegung;
+  private _lichtSonnenAufgangAus: boolean = this.defaultSettings.lichtSonnenAufgangAus;
+  private _sonnenUntergangRollos: boolean = this.defaultSettings.sonnenUntergangRollos;
+  private _sonnenAufgangRollos: boolean = this.defaultSettings.sonnenAufgangRollos;
+  private _movementResetTimer: number = this.defaultSettings.movementResetTimer;
+  private _sonnenUntergangRolloDelay: number = this.defaultSettings.sonnenUntergangRolloDelay;
+  private _sonnenUntergangRolloMaxTime: iTimePair = this.defaultSettings.sonnenUntergangRolloMaxTime;
+  private _sonnenUntergangLampenDelay: number = this.defaultSettings.sonnenUntergangLampenDelay;
+  private _sonnenAufgangRolloDelay: number = this.defaultSettings.sonnenAufgangRolloDelay;
+  private _sonnenAufgangRolloMinTime: iTimePair = this.defaultSettings.sonnenAufgangRolloMinTime;
+  private _sonnenAufgangLampenDelay: number = this.defaultSettings.sonnenAufgangLampenDelay;
+  private _lightIfNoWindows: boolean = this.defaultSettings.lightIfNoWindows;
+  public hmIpSettings?: HmIpRoomSettings;
+  public zigbeeSettings?: ZigbeeRoomSettings;
+  public radioUrl: string = 'https://hermes.bcs-systems.de/hitradio-rtl_top40_64k_aac'; // Radio RTL
+  public etage: number = -1;
+  public rolloOffset: SunTimeOffsets;
+  public lampOffset: SunTimeOffsets;
+  public room?: RoomBase;
+  public rolloHeatReduction: boolean = this.defaultSettings.rolloHeatReduction;
+
+  public constructor(public shortName: string) {
+    this.rolloOffset = new SunTimeOffsets(
+      this.sonnenAufgangRolloDelay,
+      this.sonnenUntergangRolloDelay,
+      this.sonnenAufgangRolloMinTime.hours,
+      this.sonnenAufgangRolloMinTime.minutes,
+      this.sonnenUntergangRolloMaxTime.hours,
+      this.sonnenUntergangRolloMaxTime.minutes,
+    );
+    this.lampOffset = new SunTimeOffsets(this.sonnenAufgangLampenDelay, this.sonnenUntergangLampenDelay);
+  }
+
+  private recalcRolloOffset(): void {
+    this.rolloOffset = new SunTimeOffsets(
+      this.sonnenAufgangRolloDelay,
+      this.sonnenUntergangRolloDelay,
+      this.sonnenAufgangRolloMinTime.hours,
+      this.sonnenAufgangRolloMinTime.minutes,
+      this.sonnenUntergangRolloMaxTime.hours,
+      this.sonnenUntergangRolloMaxTime.minutes,
+    );
+    if (this.room) {
+      this.room.recalcTimeCallbacks();
+    }
+  }
+
+  private recalcLampOffset(): void {
+    this.lampOffset = new SunTimeOffsets(this.sonnenAufgangLampenDelay, this.sonnenAufgangRolloDelay);
+    if (this.room) {
+      this.room.recalcTimeCallbacks();
+    }
+  }
+
+  get sonnenAufgangLampenDelay(): number {
+    return this._sonnenAufgangLampenDelay;
+  }
+
+  set sonnenAufgangLampenDelay(value: number) {
+    this._sonnenAufgangLampenDelay = value;
+    this.recalcLampOffset();
+  }
+  get sonnenAufgangRolloDelay(): number {
+    return this._sonnenAufgangRolloDelay;
+  }
+
+  set sonnenAufgangRolloDelay(value: number) {
+    this._sonnenAufgangRolloDelay = value;
+    this.recalcRolloOffset();
+  }
+  get sonnenUntergangLampenDelay(): number {
+    return this._sonnenUntergangLampenDelay;
+  }
+
+  set sonnenUntergangLampenDelay(value: number) {
+    this._sonnenUntergangLampenDelay = value;
+    this.recalcLampOffset();
+  }
+  get sonnenUntergangRolloDelay(): number {
+    return this._sonnenUntergangRolloDelay;
+  }
+
+  set sonnenUntergangRolloDelay(value: number) {
+    this._sonnenUntergangRolloDelay = value;
+  }
+  get movementResetTimer(): number {
+    return this._movementResetTimer;
+  }
+
+  set movementResetTimer(value: number) {
+    this._movementResetTimer = value;
+  }
+  get lichtSonnenAufgangAus(): boolean {
+    return this._lichtSonnenAufgangAus;
+  }
+  get sonnenAufgangRollos(): boolean {
+    return this._sonnenAufgangRollos;
+  }
+
+  set sonnenAufgangRollos(value: boolean) {
+    this._sonnenAufgangRollos = value;
+    this.recalcRolloOffset();
+  }
+  get sonnenUntergangRollos(): boolean {
+    return this._sonnenUntergangRollos;
+  }
+
+  set sonnenUntergangRollos(value: boolean) {
+    this._sonnenUntergangRollos = value;
+    this.recalcRolloOffset();
+  }
+  set lichtSonnenAufgangAus(value: boolean) {
+    this._lichtSonnenAufgangAus = value;
+  }
+  get lampenBeiBewegung(): boolean {
+    return this._lampenBeiBewegung;
+  }
+
+  set lampenBeiBewegung(value: boolean) {
+    this._lampenBeiBewegung = value;
+  }
+
+  get sonnenUntergangRolloMaxTime(): iTimePair {
+    return this._sonnenUntergangRolloMaxTime;
+  }
+
+  set sonnenUntergangRolloMaxTime(value: iTimePair) {
+    this._sonnenUntergangRolloMaxTime = value;
+    this.recalcRolloOffset();
+  }
+
+  get sonnenAufgangRolloMinTime(): iTimePair {
+    return this._sonnenAufgangRolloMinTime;
+  }
+
+  set sonnenAufgangRolloMinTime(value: iTimePair) {
+    this._sonnenAufgangRolloMinTime = value;
+    this.recalcRolloOffset();
+  }
+
+  get lightIfNoWindows(): boolean {
+    return this._lightIfNoWindows;
+  }
+
+  set lightIfNoWindows(value: boolean) {
+    this._lightIfNoWindows = value;
+  }
+}

package/models/rooms/RoomSettings/hmIPRoomSettings.ts

@@ -0,0 +1,53 @@
+import { HmIpDeviceType } from '../../../server/devices/hmIPDevices/hmIpDeviceType';
+import { ServerLogService } from '../../../server/services/log-service';
+import { LogLevel } from '../../logLevel';
+
+export class HmIpAddDeviceItem {
+  private _added: boolean = false;
+
+  public get added(): boolean {
+    return this._added;
+  }
+
+  public set added(value: boolean) {
+    if (this._added) {
+      ServerLogService.writeLog(LogLevel.Error, `${this.customName} Added twice`);
+    }
+    this._added = value;
+  }
+
+  constructor(public setID: (value: string) => void, public index: number, public customName: string) {}
+}
+
+export class HmIpRoomSettings {
+  public devices: Array<Array<HmIpAddDeviceItem>> = [];
+
+  constructor(public RoomName: string) {}
+
+  public addDevice(
+    deviceType: HmIpDeviceType,
+    setID: (value: string) => void,
+    index: number,
+    customName: string | undefined = undefined,
+  ): void {
+    if (this.devices[deviceType] === undefined) {
+      this.devices[deviceType] = [];
+    }
+    if (customName === undefined) {
+      customName = `${this.RoomName} ${HmIpDeviceType[deviceType]}`;
+    }
+    this.devices[deviceType][index] = new HmIpAddDeviceItem(setID, index, customName);
+  }
+
+  public checkMissing(): void {
+    for (const type in this.devices) {
+      const devs = this.devices[type];
+      for (const index in devs) {
+        const dev = devs[index];
+        if (!dev.added) {
+          ServerLogService.writeLog(LogLevel.Error, `${dev.customName} fehlt in der Device JSON`);
+        }
+      }
+    }
+  }
+}

package/models/rooms/RoomSettings/iRoomDefaultSettings.ts

@@ -0,0 +1,17 @@
+import { iTimePair } from '../../../server/config/iConfig';
+
+export interface iRoomDefaultSettings {
+  rolloHeatReduction: boolean;
+  lampenBeiBewegung: boolean;
+  lichtSonnenAufgangAus: boolean;
+  sonnenUntergangRollos: boolean;
+  sonnenUntergangRolloDelay: number;
+  sonnenUntergangRolloMaxTime: iTimePair;
+  sonnenUntergangLampenDelay: number;
+  sonnenAufgangRollos: boolean;
+  sonnenAufgangRolloDelay: number;
+  sonnenAufgangRolloMinTime: iTimePair;
+  sonnenAufgangLampenDelay: number;
+  movementResetTimer: number;
+  lightIfNoWindows: boolean;
+}

package/models/rooms/RoomSettings/readme.md

@@ -0,0 +1,18 @@
+### Generate Setter for ID's ###
+```
+function fix(s) {
+  var t = [];
+  var e = s.split('\n');
+  for(var i=0;i<e.length;i++) {
+    var cI = e[i];
+    cI = cI.trim().trimStart();
+    cI = cI.replace("private static ", "");
+    cI = cI.replace(": string = '';", "");
+    cI = cI.replace(": string;", "");
+    var cL = `${cI.charAt(0).toUpperCase()}${cI.substr(1)}`;
+    t.push(`public static set${cL}(value: string): void {\n\tthis.${cI} = value;\n}`);
+  }
+  console.log(t.join("\n\n"));
+}
+fix(`YOUR_DECLARATIONS_COME_HERE`);
+```

package/models/rooms/RoomSettings/zigbeeRoomSettings.ts

@@ -0,0 +1,51 @@
+import { ZigbeeDeviceType } from '../../../server/devices/zigbee/zigbeeDeviceType';
+import { ServerLogService } from '../../../server/services/log-service';
+import { LogLevel } from '../../logLevel';
+
+export class ZigbeeAddDeviceItem {
+  private _added: boolean = false;
+
+  public get added(): boolean {
+    return this._added;
+  }
+
+  public set added(value: boolean) {
+    if (this._added) {
+      ServerLogService.writeLog(LogLevel.Error, `${this.customName} Added twice`);
+    }
+    this._added = value;
+  }
+  constructor(public setID: (value: string) => void, public index: number, public customName: string) {}
+}
+
+export class ZigbeeRoomSettings {
+  public devices: Array<Array<ZigbeeAddDeviceItem>> = [];
+  constructor(public RoomName: string) {}
+
+  public addDevice(
+    deviceType: ZigbeeDeviceType,
+    setID: (value: string) => void,
+    index: number,
+    customName: string | undefined = undefined,
+  ): void {
+    if (this.devices[deviceType] === undefined) {
+      this.devices[deviceType] = [];
+    }
+    if (customName === undefined) {
+      customName = `${this.RoomName} ${ZigbeeDeviceType[deviceType]}`;
+    }
+    this.devices[deviceType][index] = new ZigbeeAddDeviceItem(setID, index, customName);
+  }
+
+  public checkMissing(): void {
+    for (const type in this.devices) {
+      const devs = this.devices[type];
+      for (const index in devs) {
+        const dev = devs[index];
+        if (!dev.added) {
+          ServerLogService.writeLog(LogLevel.Error, `${dev.customName} fehlt in der Device JSON`);
+        }
+      }
+    }
+  }
+}

package/models/rooms/iRoomImportEnforcer.ts

@@ -0,0 +1,3 @@
+export interface iRoomImportEnforcer {
+  addRoomConstructor(): void;
+}

package/models/rooms/readme.md

@@ -0,0 +1,11 @@
+### Create Rooms
+Hoffmation is centered about rooms. 
+Many follow certain default behaviour while others have very specific rules.
+To be modular Rooms within HoffMation should be generated automatically.
+
+To do so use the Excel Document `Raumdefinition.xlsm`
+Within that document you have to create all your rooms and the devices.
+
+Afterwards you can create the resulting config code and paste that into 
+`server/config/roomConfig.txt`
+

package/models/temperaturSettings.ts

@@ -0,0 +1,22 @@
+import { Daytime } from './daytime';
+
+export class TemperaturSettings {
+  public constructor(
+    public start: Daytime,
+    public end: Daytime,
+    public temperatur: number,
+    public active: boolean = true,
+  ) {}
+
+  public isNowInRange(): boolean {
+    const now: number = new Date().getTime();
+    const todayStart: number = new Date().setHours(this.start.hour, this.start.minute);
+    if (now < todayStart) {
+      return false;
+    }
+
+    const todayEnd: number = new Date().setHours(this.end.hour, this.end.minute);
+
+    return now < todayEnd;
+  }
+}

package/models/timeCallback.ts

@@ -0,0 +1,90 @@
+import { LogLevel } from './logLevel';
+import { ServerLogService } from '/server/services/log-service';
+import { SunTimeOffsets, TimeCallbackService } from '/server/services/time-callback-service';
+
+export class TimeCallback {
+  public lastDone: Date = new Date(0);
+  public nextToDo?: Date;
+
+  constructor(
+    public name: string,
+    public type: TimeCallbackType,
+    public cFunction: () => void,
+    public minuteOffset: number,
+    public hours?: number,
+    public minutes?: number,
+    public sunTimeOffset?: SunTimeOffsets,
+  ) {}
+
+  public recalcNextToDo(now: Date): void {
+    const today: Date = new Date(now.getTime());
+    today.setHours(0, 0, 0, 0);
+    switch (this.type) {
+      case TimeCallbackType.TimeOfDay:
+        if (this.hours === undefined) {
+          this.hours = 0;
+        }
+
+        if (this.minutes === undefined) {
+          this.minutes = 0;
+        }
+
+        this.nextToDo = new Date(
+          today.getTime() + this.hours * 60 * 60 * 1000 + (this.minutes + this.minuteOffset) * 60 * 1000,
+        );
+
+        if (this.nextToDo < now) {
+          // Heute ist schon abgelaufen, also morgen festlegen
+          this.nextToDo = new Date(this.nextToDo.getTime() + 24 * 60 * 60 * 1000);
+        }
+
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Nächste Zeitevent für "${this.name}" um ${this.nextToDo.toLocaleTimeString('de-DE')}`,
+        );
+        break;
+      case TimeCallbackType.Sunrise:
+        let fixedSRDate: Date = new Date(TimeCallbackService.nextSunRise.getTime() + this.minuteOffset * 60 * 1000);
+        if (this.sunTimeOffset) {
+          const nextMinSR: Date = this.sunTimeOffset.getNextMinimumSunrise();
+          if (fixedSRDate.getDate() === nextMinSR.getDate()) {
+            fixedSRDate = nextMinSR;
+          }
+        }
+        if (now > fixedSRDate) {
+          return;
+        }
+
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Nächste Zeitevent für "${this.name}" um ${fixedSRDate.toLocaleTimeString('de-DE')}`,
+        );
+        this.nextToDo = fixedSRDate;
+        break;
+      case TimeCallbackType.SunSet:
+        let fixedSSDate: Date = new Date(TimeCallbackService.nextSunSet.getTime() + this.minuteOffset * 60 * 1000);
+        if (this.sunTimeOffset) {
+          const nextMaxSS: Date = this.sunTimeOffset.getNextMaximumSunset();
+          if (fixedSSDate.getDate() === nextMaxSS.getDate()) {
+            fixedSSDate = nextMaxSS;
+          }
+        }
+        if (now > fixedSSDate) {
+          return;
+        }
+
+        ServerLogService.writeLog(
+          LogLevel.Trace,
+          `Nächste Zeitevent für "${this.name}" um ${fixedSSDate.toLocaleTimeString('de-DE')}`,
+        );
+        this.nextToDo = fixedSSDate;
+        break;
+    }
+  }
+}
+
+export enum TimeCallbackType {
+  TimeOfDay = 1,
+  Sunrise = 2,
+  SunSet = 3,
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "hoffmation-base",
+  "description": "Base Libraries and functions for own Hoffmation projects",
+  "version": "0.0.1",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theimo1221/Hoffmation-Base.git"
+  },
+  "author": "Thiemo Hoffmann",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/theimo1221/Hoffmation-Base/issues"
+  },
+  "homepage": "https://github.com/theimo1221/Hoffmation-Base#readme",
+  "scripts": {
+    "lint-fix-all": "eslint ./**/{*.ts,*.js} --fix --no-error-on-unmatched-pattern"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.15.4",
+    "@svrooij/sonos": "^2.4.1",
+    "aws-sdk": "2.999.0",
+    "bcrypt": "^5.0.1",
+    "get-mp3-duration": "^1.0.0",
+    "html-entities": "^2.3.2",
+    "https": "^1.0.0",
+    "iobroker.socketio": "^3.1.4",
+    "jquery": "^3.6.0",
+    "mocha": "^9.1.2",
+    "node-ical": "^0.13.0",
+    "node-telegram-bot-api": "^0.54.0",
+    "semantic-ui-react": "^2.0.4",
+    "socket.io-client": "2.4.x",
+    "sunrise-sunset-js": "^2.2.1",
+    "underscore": "^1.13.1",
+    "ws": "^7.5.5"
+  },
+  "devDependencies": {
+    "@types/meteor": "^1.4.78",
+    "@types/mocha": "^9.0.0",
+    "@types/node-telegram-bot-api": "^0.53.0",
+    "@types/iobroker": "^3.3.4",
+    "@types/node": "^16.10.2",
+    "@types/socket.io-client": "^1.4.36",
+    "@types/ws": "^7.4.7",
+    "@typescript-eslint/eslint-plugin": "^4.32.0",
+    "@typescript-eslint/parser": "^4.32.0",
+    "autoprefixer": "^10.3.6",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "4.0.0",
+    "postcss": "^8.3.8",
+    "postcss-load-config": "^3.1.0",
+    "prettier": "^2.4.1",
+    "typescript": "^4.4.3"
+  }
+}

package/server/config/config-readme.md

@@ -0,0 +1,19 @@
+# Config
+This home automation system is configured using multiple files which are described below.
+
+## Device Config
+To highly decrease workload manually entering device data from ioBroker 
+you can simply download your whole object tree from within the ioBroker -> objects page.
+
+The resulting `.json` should be placed within `.\server\config\private` folder, renamed to `devices.json`
+
+## Main Config
+Please place a `mainConfig.json` in the `.\server\config\private` folder.
+
+The file should contain all the desired services, which definitions can be found within the `iConfig.ts` file.
+
+## RoomConfig
+Please use the `.\models\rooms\Raumdefinition.xlsm` excel sheet to
+generate a `RoomConfig.txt`. As this needs running a specific node script 
+afterwards you should follow the steps within `.\models\rooms\readme.md`
+

package/server/config/iConfig.ts

@@ -0,0 +1,53 @@
+import { LogLevel } from '../../models/logLevel';
+import { iRoomDefaultSettings } from '../../models/rooms/RoomSettings/iRoomDefaultSettings';
+
+export interface iConfig {
+  roomDefault: iRoomDefaultSettings;
+  timeSettings: iTimeSettings;
+  ioBrokerUrl: string;
+  telegram?: iTelegramSettings;
+  polly?: iPollySettings;
+  mp3Server?: iMp3Settings;
+  weather?: iWeatherSettings;
+  muell?: iMuellSettings;
+}
+
+export interface iTimePair {
+  hours: number;
+  minutes: number;
+}
+
+export interface iTimeSettings {
+  nightStart: iTimePair;
+  nightEnd: iTimePair;
+}
+
+export interface iTelegramSettings {
+  logLevel: LogLevel;
+  telegramToken: string;
+  allowedIDs: number[];
+  subscribedIDs: number[];
+}
+
+export interface iPollySettings {
+  mp3Path: string;
+  region: string;
+  signatureVersion: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  voiceID: string;
+}
+
+export interface iMp3Settings {
+  path: string;
+}
+
+export interface iWeatherSettings {
+  lattitude: string;
+  longitude: string;
+  appid: string;
+}
+
+export interface iMuellSettings {
+  calendarURL: string;
+}

package/server/devices/DeviceInfo.ts

@@ -0,0 +1,66 @@
+import { deviceConfig } from '/models/deviceConfig';
+
+export class DeviceInfo {
+  public devID: string;
+  public room: string;
+  public deviceType: string;
+  public deviceRoomIndex: number;
+  public type: 'device' | 'channel' | 'state';
+  public fullName: string;
+  private _customName?: string;
+  public fullID: string;
+  public channel?: number;
+  public valueName?: string;
+  public devConf: deviceConfig;
+
+  public constructor(pDevConf: deviceConfig) {
+    this.devConf = pDevConf;
+    this.type = pDevConf.type as 'device' | 'channel' | 'state';
+
+    this.fullID = pDevConf._id;
+    /**
+     * 0: hm-rpc
+     * 1: rcpInstance
+     * 2: Device ID
+     * 3?: Channel
+     * 4?: ValueName
+     */
+    const idSplit: string[] = pDevConf._id.split('.');
+    this.devID = idSplit[2];
+
+    if (idSplit.length > 3) {
+      this.channel = Number(idSplit[3]);
+    }
+
+    if (idSplit.length > 4) {
+      this.valueName = idSplit[4];
+    }
+
+    this.fullName = pDevConf.common.name;
+    /**
+     * 0: Indikator own "00"
+     * 1: "HmIP"
+     * 2: Raum
+     * 3: Was für ein Gerät
+     * 4: Index dieses Gerätes im Raum (ggf. + :Channel)
+     * 5?: Name des Wertes
+     */
+    const nameSplit: string[] = pDevConf.common.name.split('-');
+
+    this.room = nameSplit[2];
+    this.deviceType = nameSplit[3];
+    this.deviceRoomIndex = Number(nameSplit[4].split(':')[0]);
+  }
+
+  public set customName(val: string) {
+    this._customName = val;
+  }
+
+  public get customName(): string {
+    if (this._customName !== undefined) {
+      return this._customName;
+    }
+
+    return this.fullName;
+  }
+}

package/server/devices/Griffe.ts

@@ -0,0 +1,31 @@
+import { Devices } from './devices';
+import { FensterPosition } from './hmIPDevices/FensterPosition';
+import { HmIpDeviceType } from './hmIPDevices/hmIpDeviceType';
+import { HmIpGriff } from './hmIPDevices/hmIpGriff';
+
+export class Griffe {
+  public static getGriffPosition(): string {
+    const griffe: HmIpGriff[] = Griffe.getAllGriffe();
+    griffe.sort((a, b): number => {
+      a.position;
+      return b.position - a.position;
+    });
+
+    const response: string[] = [`Dies sind die aktuellen Stellungen der FensterGriffe:`];
+    for (const g of griffe) {
+      response.push(`${FensterPosition[g.position]} Fenster: "${g.info.customName}"`);
+    }
+    return response.join('\n');
+  }
+
+  public static getAllGriffe(): HmIpGriff[] {
+    const griffe: HmIpGriff[] = [];
+    for (const dID in Devices.hmIP) {
+      const d = Devices.hmIP[dID];
+      if (d.deviceType === HmIpDeviceType.HmIpGriff) {
+        griffe.push(d as HmIpGriff);
+      }
+    }
+    return griffe;
+  }
+}