hoffmation-base 3.0.0-alpha.9 → 3.0.0-alpha.90

package/lib/server/services/calendar/m/303/274ll-service.d.ts

@@ -1,20 +1,35 @@
-import { TimeCallback } from '../../../models';
 import { iMuellSettings } from '../../config';
 import { MuellTonne } from './muell-tonne';
 import { iSpeaker } from '../../devices';
+import { NameDatePair } from './name-date-pair';
 export declare class MuellService {
-    static alleTonnen: Array<{
-        name: string;
-        date: Date;
-    }>;
+    /**
+     * A list of all trash bins
+     */
+    static alleTonnen: NameDatePair[];
+    /**
+     * The blue trash bin (normally being used for paper)
+     */
     static blaueTonne: MuellTonne;
+    /**
+     * The grey trash bin (normally being used for general waste)
+     */
     static graueTonne: MuellTonne;
+    /**
+     * The yellow trash bin (normally being used for plastic)
+     */
     static gelbeTonne: MuellTonne;
+    /**
+     * The brown trash bin (normally being used for organic waste)
+     */
     static brauneTonne: MuellTonne;
+    /**
+     * Whether the loading of the calendar is still pending
+     */
     static loadingPending: boolean;
-    static updateTimeCallback: TimeCallback;
-    static checkTimeCallback: TimeCallback;
-    static months: string[];
+    private static updateTimeCallback;
+    private static checkTimeCallback;
+    private static months;
     private static lastCheck;
     private static _calendarURL;
     private static _active;

package/lib/server/services/calendar/m/303/274ll-service.js

@@ -23,7 +23,7 @@ class MuellService {
         this.updateCalendar();
     }
     static updateCalendar(checkAfterwards = true) {
-        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Muell Service wird nun initialisiert`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, 'Muell Service wird nun initialisiert');
         node_ical_1.async
             .fromURL(this._calendarURL)
             .then((data) => {
@@ -42,7 +42,7 @@ class MuellService {
                     continue;
                 }
                 const ev = data[k];
-                log_service_1.ServerLogService.writeLog(models_1.LogLevel.DeepTrace, `${ev.summary} is in ${ev.location} on the ${ev.start.getDate()} of ${this.months[ev.start.getMonth()]} at ${ev.start.toLocaleTimeString('en-GB')}`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.DeepTrace, `${ev.summary} is in ${ev.location} on the ${ev.start.getDate()} of ${this.months[ev.start.getMonth()]} at ${ev.start.toLocaleTimeString('de-DE')}`);
                 if (ev.start.getTime() < todayMidnight) {
                     continue;
                 }
@@ -84,18 +84,18 @@ class MuellService {
         }
         const now = new Date();
         if (now.getTime() - this.lastCheck.getTime() < 60000 && now.getDate() === this.lastCheck.getDate()) {
-            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `MüllService.checkAll: Skipped weil wir gerade erst geprüft hatten.`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, 'MüllService.checkAll: Skipped weil wir gerade erst geprüft hatten.');
             return;
         }
         if (this.gelbeTonne === undefined) {
             if (pRetries > 0) {
-                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Der Müllservice ist noch nicht bereit --> warten`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, 'Der Müllservice ist noch nicht bereit --> warten');
                 utils_1.Utils.guardedTimeout(() => {
                     MuellService.checkAll(pRetries - 1);
                 }, 1000);
             }
             else {
-                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Der Müllservice ist trotz Warten nicht bereit --> Abbruch`);
+                log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, 'Der Müllservice ist trotz Warten nicht bereit --> Abbruch');
             }
             return;
         }
@@ -107,7 +107,13 @@ class MuellService {
     }
 }
 exports.MuellService = MuellService;
+/**
+ * A list of all trash bins
+ */
 MuellService.alleTonnen = [];
+/**
+ * Whether the loading of the calendar is still pending
+ */
 MuellService.loadingPending = true;
 MuellService.months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 MuellService.lastCheck = new Date(0);

package/lib/server/services/calendar/name-date-pair.d.ts

@@ -0,0 +1,5 @@
+export declare class NameDatePair {
+    name: string;
+    date: Date;
+    constructor(name: string, date: Date);
+}

package/lib/server/services/calendar/name-date-pair.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameDatePair = void 0;
+class NameDatePair {
+    constructor(name, date) {
+        this.name = name;
+        this.date = date;
+    }
+}
+exports.NameDatePair = NameDatePair;

package/lib/server/services/dbo/iPersist.d.ts

@@ -1,27 +1,130 @@
 import { ButtonPressType, iAcDevice, iActuator, iBaseDevice, iBatteryDevice, iButtonSwitch, iHandleSensor, iHeater, iHumiditySensor, iIlluminationSensor, iMotionSensor, iShutter, iTemperatureSensor, ZigbeeDevice } from '../../devices';
 import { CountToday, DesiredShutterPosition, EnergyCalculation, RoomBase, ShutterCalibration } from '../../../models';
+/**
+ * The interface to interact with the persistence layer.
+ * In the past there was a mongo-db implementation, but this is now replaced by currently only postgresSql.
+ */
 export interface iPersist {
+    /**
+     * Whether persistence is properly initialized
+     */
     initialized: boolean;
+    /**
+     * Adds a room to the database
+     * @param room - The room to add
+     */
     addRoom(room: RoomBase): void;
+    /**
+     * Adds a device to the database
+     * @param device - The device to add
+     */
     addDevice(device: iBaseDevice): void;
+    /**
+     * Gets the count of the motion sensor today
+     * @param device - The device to get the count for
+     * @returns - The count of the motion sensor today
+     */
     motionSensorTodayCount(device: iMotionSensor): Promise<CountToday>;
+    /**
+     * Gets the last desired position of the shutter
+     * @param device - The device to get the last desired position for
+     * @returns - The last desired position of the shutter
+     */
     getLastDesiredPosition(device: iShutter): Promise<DesiredShutterPosition>;
+    /**
+     * Gets the shutter calibration
+     * @param device - The device to get the shutter calibration for
+     * @returns - The shutter calibration
+     */
     getShutterCalibration(device: iShutter): Promise<ShutterCalibration>;
+    /**
+     * Initializes the database-connection and prepares the database
+     * @returns - The promise that resolves when the database is initialized
+     */
     initialize(): Promise<void>;
+    /**
+     * Persists the shutter calibration
+     * @param data - The shutter calibration data to persist
+     */
     persistShutterCalibration(data: ShutterCalibration): void;
+    /**
+     * Persists data for an illumination sensor
+     * @param device - The device to persist data for
+     */
     persistIlluminationSensor(device: iIlluminationSensor): void;
+    /**
+     * Persists data for an energy manager
+     * @param energyData - The energy data to persist
+     */
     persistEnergyManager(energyData: EnergyCalculation): void;
+    /**
+     * Persists data of an AC device
+     * @param device - The device to persist data for
+     */
     persistAC(device: iAcDevice): void;
+    /**
+     * Persists data of an actuator
+     * @param device - The device to persist data for
+     */
     persistActuator(device: iActuator): void;
+    /**
+     * Persists data of a heater
+     * @param device - The device to persist data for
+     */
     persistHeater(device: iHeater): void;
+    /**
+     * Persists data of a motion sensor
+     * @param device - The device to persist data for
+     */
     persistMotionSensor(device: iMotionSensor): void;
+    /**
+     * Persists data of a button switch action
+     * @param device - The device to persist data for
+     * @param pressType - The type of button press
+     * @param buttonName - The name of the button
+     */
     persistSwitchInput(device: iButtonSwitch, pressType: ButtonPressType, buttonName: string): void;
+    /**
+     * Persists data of a shutter
+     * @param device - The device to persist data for
+     */
     persistShutter(device: iShutter): void;
+    /**
+     * Persists data of a temperature sensor
+     * @param device - The device to persist data for
+     */
     persistTemperatureSensor(device: iTemperatureSensor): void;
+    /**
+     * Persists data of a humidity sensor
+     * @param device - The device to persist data for
+     */
     persistHumiditySensor(device: iHumiditySensor): void;
+    /**
+     * Persists data of a handle sensor
+     * @param device - The device to persist data for
+     */
     persistHandleSensor(device: iHandleSensor): void;
+    /**
+     * Persists data of a battery device
+     * @param device - The device to persist data for
+     */
     persistBatteryDevice(device: iBatteryDevice): void;
+    /**
+     * Persists data of a Zigbee device
+     * @param device - The device to persist data for
+     */
     persistZigbeeDevice(device: ZigbeeDevice): void;
+    /**
+     * Persists settings for the given id
+     * @param id - The id to persist settings for
+     * @param settings - The settings to persist (as JSON string)
+     * @param customname - The custom name of the device/object
+     */
     persistSettings(id: string, settings: string, customname: string): void;
+    /**
+     * Loads settings for the given id
+     * @param id - The id of the object/device to load settings for
+     * @returns - The settings as JSON string or undefined if not found
+     */
     loadSettings(id: string): Promise<string | undefined>;
 }

package/lib/server/services/dbo/postgreSqlPersist.d.ts

@@ -3,31 +3,54 @@ import { CountToday, DesiredShutterPosition, EnergyCalculation, RoomBase, Shutte
 import { ButtonPressType, iAcDevice, iActuator, iBaseDevice, iBatteryDevice, iButtonSwitch, iHandleSensor, iHeater, iHumiditySensor, iIlluminationSensor, iMotionSensor, iShutter, iTemperatureSensor, ZigbeeDevice } from '../../devices';
 import { PoolConfig } from 'pg';
 export declare class PostgreSqlPersist implements iPersist {
+    /** @inheritDoc */
     initialized: boolean;
     private readonly psql;
     private readonly config;
     constructor(conf: PoolConfig);
+    /** @inheritDoc */
     addRoom(room: RoomBase): void;
+    /** @inheritDoc */
     addDevice(device: iBaseDevice): void;
+    /** @inheritDoc */
     getLastDesiredPosition(device: iShutter): Promise<DesiredShutterPosition>;
+    /** @inheritDoc */
     motionSensorTodayCount(device: iMotionSensor): Promise<CountToday>;
+    /** @inheritDoc */
     getShutterCalibration(_device: iShutter): Promise<ShutterCalibration>;
+    /** @inheritDoc */
     initialize(): Promise<void>;
+    /** @inheritDoc */
     persistAC(device: iAcDevice): void;
+    /** @inheritDoc */
     persistActuator(device: iActuator): void;
+    /** @inheritDoc */
     persistHeater(device: iHeater): void;
+    /** @inheritDoc */
     persistHandleSensor(device: iHandleSensor): void;
+    /** @inheritDoc */
     persistSwitchInput(device: iButtonSwitch, pressType: ButtonPressType, buttonName: string): void;
+    /** @inheritDoc */
     persistMotionSensor(device: iMotionSensor): void;
+    /** @inheritDoc */
     persistShutter(device: iShutter): void;
+    /** @inheritDoc */
     persistTemperatureSensor(device: iTemperatureSensor): void;
+    /** @inheritDoc */
     persistHumiditySensor(device: iHumiditySensor): void;
+    /** @inheritDoc */
     persistBatteryDevice(device: iBatteryDevice): void;
+    /** @inheritDoc */
     persistZigbeeDevice(device: ZigbeeDevice): void;
+    /** @inheritDoc */
     persistIlluminationSensor(device: iIlluminationSensor): void;
+    /** @inheritDoc */
     persistShutterCalibration(_data: ShutterCalibration): void;
+    /** @inheritDoc */
     persistEnergyManager(calc: EnergyCalculation): void;
+    /** @inheritDoc */
     persistSettings(id: string, settings: string, customName: string): void;
+    /** @inheritDoc */
     loadSettings(id: string): Promise<string | undefined>;
     private query;
     private isPsqlReady;

package/lib/server/services/dbo/postgreSqlPersist.js

@@ -9,10 +9,12 @@ const DeviceCapability_1 = require("../../devices/DeviceCapability");
 const utils_1 = require("../utils");
 class PostgreSqlPersist {
     constructor(conf) {
+        /** @inheritDoc */
         this.initialized = false;
         this.config = conf;
         this.psql = new pg_1.Pool(this.config);
     }
+    /** @inheritDoc */
     addRoom(room) {
         this.query(`
 insert into hoffmation_schema."BasicRooms" (name, etage)
@@ -23,6 +25,7 @@ values ('${room.roomName}',${room.etage})
 ;
     `);
     }
+    /** @inheritDoc */
     addDevice(device) {
         this.query(`
 insert into hoffmation_schema."DeviceInfo" ("deviceid", "roomname", "alldeviceskey", "customname", "devtype")
@@ -36,6 +39,7 @@ values ('${device.id}','${device.info.room}','${device.info.allDevicesKey}','${d
 ;
     `);
     }
+    /** @inheritDoc */
     async getLastDesiredPosition(device) {
         const dbResult = await this.query(`SELECT position
 from hoffmation_schema."ShutterDeviceData"
@@ -49,6 +53,7 @@ Limit 1`);
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Es gibt noch keine persistierten Bewegungen für ${device.info.fullName}`);
         return new models_1.DesiredShutterPosition(-1);
     }
+    /** @inheritDoc */
     async motionSensorTodayCount(device) {
         const dbResult = await this.query(`SELECT Count(*) 
 from hoffmation_schema."MotionSensorDeviceData" 
@@ -61,12 +66,14 @@ WHERE "deviceID" = '${device.id}' and "movementDetected" and date >= CURRENT_DAT
         log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Es gibt noch keine persistierten Bewegungen für ${device.info.fullName}`);
         return new models_1.CountToday(0);
     }
+    /** @inheritDoc */
     getShutterCalibration(_device) {
-        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Postgres doesn't support Shutter Calibration yet.`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, "Postgres doesn't support Shutter Calibration yet.");
         return new Promise((_res, reject) => {
             reject('Not Implemented');
         });
     }
+    /** @inheritDoc */
     async initialize() {
         await this.psql.connect();
         // Execute BasicRoomsDDL
@@ -338,14 +345,16 @@ BEGIN
 END
 $$;`);
         this.initialized = true;
-        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Postgres DB initialized`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Info, 'Postgres DB initialized');
     }
+    /** @inheritDoc */
     persistAC(device) {
         this.query(`
 insert into hoffmation_schema."AcDeviceData" ("deviceID", "on", "date", "roomTemperature")
 values ('${device.id}', ${device.on}, '${new Date().toISOString()}', ${device.temperature});
     `);
     }
+    /** @inheritDoc */
     persistActuator(device) {
         let percentage = undefined;
         if (device.deviceCapabilities.includes(DeviceCapability_1.DeviceCapability.dimmablelamp)) {
@@ -356,6 +365,7 @@ insert into hoffmation_schema."ActuatorDeviceData" ("deviceID", "on", "date", "p
 values ('${device.id}', ${device.actuatorOn}, '${new Date().toISOString()}', ${percentage !== null && percentage !== void 0 ? percentage : 'null'});
     `);
     }
+    /** @inheritDoc */
     persistHeater(device) {
         let roomTemp = device.roomTemperature;
         let desiredTemperature = device.desiredTemperature;
@@ -370,6 +380,7 @@ insert into hoffmation_schema."HeaterDeviceData" ("deviceID", "level", "date", "
 values ('${device.id}', ${device.iLevel}, '${new Date().toISOString()}', ${roomTemp !== null && roomTemp !== void 0 ? roomTemp : 'null'}, ${desiredTemperature !== null && desiredTemperature !== void 0 ? desiredTemperature : 'null'}, ${device.seasonTurnOff});
     `);
     }
+    /** @inheritDoc */
     persistHandleSensor(device) {
         const currentPos = device.position;
         this.query(`
@@ -377,18 +388,21 @@ insert into hoffmation_schema."HandleDeviceData" ("deviceID", "position", "date"
 values ('${device.id}', ${currentPos}, '${new Date().toISOString()}');
     `);
     }
+    /** @inheritDoc */
     persistSwitchInput(device, pressType, buttonName) {
         this.query(`
 insert into hoffmation_schema."ButtonSwitchPresses" ("deviceID", "pressType", "buttonName", "date")
 values ('${device.id}', ${pressType}, '${buttonName}', '${new Date().toISOString()}');
     `);
     }
+    /** @inheritDoc */
     persistMotionSensor(device) {
         this.query(`
 insert into hoffmation_schema."MotionSensorDeviceData" ("deviceID", "movementDetected", "date")
 values ('${device.id}', ${device.movementDetected}, '${new Date().toISOString()}');
     `);
     }
+    /** @inheritDoc */
     persistShutter(device) {
         const currentLevel = device.currentLevel >= 0 ? device.currentLevel : null;
         const desiredLevel = device.desiredWindowShutterLevel >= 0 ? device.desiredWindowShutterLevel : null;
@@ -397,6 +411,7 @@ insert into hoffmation_schema."ShutterDeviceData" ("deviceID", "position", "date
 values ('${device.id}', ${currentLevel}, '${new Date().toISOString()}', ${desiredLevel});
     `);
     }
+    /** @inheritDoc */
     persistTemperatureSensor(device) {
         let roomTemp = device.roomTemperature;
         if (roomTemp === devices_1.UNDEFINED_TEMP_VALUE) {
@@ -407,18 +422,21 @@ insert into hoffmation_schema."TemperatureSensorDeviceData" ("deviceID", "temper
 values ('${device.id}', ${device.iTemperature}, '${new Date().toISOString()}', ${roomTemp !== null && roomTemp !== void 0 ? roomTemp : 'null'});
     `);
     }
+    /** @inheritDoc */
     persistHumiditySensor(device) {
         this.query(`
 insert into hoffmation_schema."HumiditySensorDeviceData" ("deviceID", "humidity", "date")
 values ('${device.id}', ${device.humidity}, '${new Date().toISOString()}');
     `);
     }
+    /** @inheritDoc */
     persistBatteryDevice(device) {
         this.query(`
 insert into hoffmation_schema."BatteryDeviceData" ("deviceID", "battery", "date")
-values ('${device.id}', ${utils_1.Utils.round(device.battery, 1)}, '${new Date().toISOString()}');
+values ('${device.id}', ${utils_1.Utils.round(device.batteryLevel, 1)}, '${new Date().toISOString()}');
     `);
     }
+    /** @inheritDoc */
     persistZigbeeDevice(device) {
         const dateValue = device.lastUpdate.getTime() > 0 ? `'${device.lastUpdate.toISOString()}'` : 'null';
         this.query(`
@@ -426,14 +444,17 @@ insert into hoffmation_schema."ZigbeeDeviceData" ("deviceID", "date", "available
 values ('${device.id}', '${new Date().toISOString()}', ${device.available}, ${device.linkQuality}, ${dateValue});
     `);
     }
+    /** @inheritDoc */
     persistIlluminationSensor(device) {
         this.query(`
 insert into hoffmation_schema."IlluminationSensorDeviceData" ("deviceID", "illumination", "date")
 values ('${device.id}', ${device.currentIllumination}, '${new Date().toISOString()}');`);
     }
+    /** @inheritDoc */
     persistShutterCalibration(_data) {
-        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Postgres doesn't support Shutter Calibration yet.`);
+        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, "Postgres doesn't support Shutter Calibration yet.");
     }
+    /** @inheritDoc */
     persistEnergyManager(calc) {
         this.query(`
 insert into hoffmation_schema."EnergyCalculation" ("startDate", "endDate", "selfConsumedKwH", "injectedKwH",
@@ -442,6 +463,7 @@ values ('${new Date(calc.startMs).toISOString()}','${new Date(calc.endMs).toISOS
         ${calc.selfConsumedKwH}, ${calc.injectedKwH}, ${calc.drawnKwH}, ${calc.batteryStoredKwH}, ${calc.batteryLevel});
     `);
     }
+    /** @inheritDoc */
     persistSettings(id, settings, customName) {
         this.query(`
 insert into hoffmation_schema."Settings" (id, settings, customname, date)
@@ -453,6 +475,7 @@ values ('${id}','${settings}','${customName}', '${new Date().toISOString()}')
 ;
     `);
     }
+    /** @inheritDoc */
     async loadSettings(id) {
         const dbResult = await this.query(`SELECT settings, id, date
 from hoffmation_schema."Settings" 
@@ -484,11 +507,11 @@ LIMIT 1`);
     }
     isPsqlReady() {
         if (!this.initialized) {
-            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Db is not yet initialized`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, 'Db is not yet initialized');
             return false;
         }
         if (!this.psql) {
-            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `PSQL client missing`);
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, 'PSQL client missing');
             return false;
         }
         return true;

package/lib/server/services/file-info.d.ts

@@ -0,0 +1,5 @@
+export declare class FileInfo {
+    readonly mime: string;
+    readonly size: number;
+    constructor(mime: string, size: number);
+}

package/lib/server/services/file-info.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileInfo = void 0;
+class FileInfo {
+    constructor(mime, size) {
+        this.mime = mime;
+        this.size = size;
+    }
+}
+exports.FileInfo = FileInfo;

package/lib/server/services/govee/govee-device-data.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Interface for any device data updates
+ */
+export interface GoveeDeviceData {
+    /**
+     * The device id form Govee
+     */
+    id: string;
+    /**
+     * The current state
+     */
+    actuatorOn: boolean;
+    /**
+     * The active brightness
+     */
+    brightness: number;
+    /**
+     * The hex coded active color starting with #
+     */
+    hexColor: string;
+    /**
+     * The colortemp
+     */
+    colortemp: number;
+}

package/lib/server/services/govee/govee-device-data.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/server/services/govee/govee-service.d.ts

@@ -1,16 +1,14 @@
 import { OwnGoveeDevice } from './own-govee-device';
-import { Device as GoveeDevice } from '@j3lte/govee-lan-controller';
+import { iGoveeSettings } from '../../config';
 export declare class GooveeService {
-    static all: GoveeDevice[];
-    static devicesDict: {
-        [name: string]: GoveeDevice;
-    };
-    private static goveeApi;
+    private static _serverUrl;
     private static ownDevices;
+    private static _refreshInterval;
     static addOwnDevices(gvDevice: {
         [name: string]: OwnGoveeDevice;
     }): void;
-    static initialize(): void;
-    private static initializeDevice;
-    private static updateDevice;
+    static initialize(config: iGoveeSettings): void;
+    static cleanup(): void;
+    static sendCommand(device: OwnGoveeDevice, command: string): Promise<boolean>;
+    private static loadDevices;
 }