hoffmation-base 3.0.0-alpha.23 → 3.0.0-alpha.25

package/lib/server/services/blockAutomaticHandler.js

@@ -7,6 +7,10 @@ exports.BlockAutomaticHandler = void 0;
 const models_1 = require("../../models");
 const utils_1 = require("./utils");
 const lodash_1 = __importDefault(require("lodash"));
+/**
+ * This class is responsible for blocking automatic actions for a specific duration.
+ * It also provides the possibility to lift the block before the duration is over {@link BlockAutomaticLiftBlockCommand}.
+ */
 class BlockAutomaticHandler {
     constructor(restoreAutomaticCb) {
         this._automaticBlockedUntil = new Date(0);
@@ -23,7 +27,7 @@ class BlockAutomaticHandler {
         return this._automaticBlockedUntil > new Date();
     }
     disableAutomatic(c) {
-        this.disableAutomaticUntil(new models_1.BlockAutomaticUntilCommand(c, new Date(utils_1.Utils.nowMS() + c.durationMS), '', c.onCollideAction));
+        this.disableAutomaticUntil(new models_1.BlockAutomaticUntilCommand(c, new Date(utils_1.Utils.nowMS() + c.durationMS), '', c.onCollideAction, c.revertToAutomaticAtBlockLift));
     }
     disableAutomaticUntil(c) {
         const now = new Date();
@@ -33,20 +37,28 @@ class BlockAutomaticHandler {
             return;
         }
         this.automaticBlockedUntil = c.targetDate;
-        this.updateRestoreTimeout(new models_1.RestoreTargetAutomaticValueCommand(c, 'Restore to automatic state after block.'));
+        if (c.revertToAutomaticAtBlockLift) {
+            this.updateRestoreTimeout(new models_1.RestoreTargetAutomaticValueCommand(c, 'Restore to automatic state after block.'));
+        }
+        else {
+            this.removeRestoreTimeout();
+        }
     }
     liftAutomaticBlock(c) {
-        if (this._restoreAutomaticStateTimeout !== null) {
-            clearTimeout(this._restoreAutomaticStateTimeout);
-        }
-        this._restoreAutomaticStateTimeout = null;
+        this.removeRestoreTimeout();
         this.automaticBlockedUntil = new Date(0);
-        this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(c));
+        if (c.revertToAutomatic) {
+            this._restoreAutomatic(new models_1.RestoreTargetAutomaticValueCommand(c));
+        }
     }
-    updateRestoreTimeout(c) {
+    removeRestoreTimeout() {
         if (this._restoreAutomaticStateTimeout !== null) {
             clearTimeout(this._restoreAutomaticStateTimeout);
+            this._restoreAutomaticStateTimeout = null;
         }
+    }
+    updateRestoreTimeout(c) {
+        this.removeRestoreTimeout();
         this._restoreAutomaticStateTimeout = utils_1.Utils.guardedTimeout(() => {
             this._restoreAutomatic(c);
         }, this._automaticBlockedUntil.getTime() - utils_1.Utils.nowMS() + 500, this);

package/lib/server/services/calendar/index.d.ts

@@ -1,2 +1,3 @@
 export * from './muell-tonne';
 export * from './müll-service';
+export { NameDatePair } from './name-date-pair';

package/lib/server/services/calendar/index.js

@@ -14,5 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameDatePair = void 0;
 __exportStar(require("./muell-tonne"), exports);
 __exportStar(require("./m\u00FCll-service"), exports);
+var name_date_pair_1 = require("./name-date-pair");
+Object.defineProperty(exports, "NameDatePair", { enumerable: true, get: function () { return name_date_pair_1.NameDatePair; } });

package/lib/server/services/calendar/muell-tonne.d.ts

@@ -2,8 +2,18 @@ import { iSpeaker } from '../../devices';
 export declare class MuellTonne {
     name: string;
     ownSpeaker?: iSpeaker | undefined;
-    static oneDay: number;
+    /**
+     * The duration of a signle day in milliseconds (used for date calculations)
+     */
+    private static readonly oneDay;
+    /**
+     * The next date this bin will be emptied
+     */
     nextDate: Date | undefined;
+    /**
+     * All dates this bin will be emptied
+     * After a date has passed it will be removed
+     */
     dates: Date[];
     constructor(name: string, ownSpeaker?: iSpeaker | undefined);
     sortDates(): void;

package/lib/server/services/calendar/muell-tonne.js

@@ -8,7 +8,14 @@ class MuellTonne {
     constructor(name, ownSpeaker) {
         this.name = name;
         this.ownSpeaker = ownSpeaker;
+        /**
+         * The next date this bin will be emptied
+         */
         this.nextDate = undefined;
+        /**
+         * All dates this bin will be emptied
+         * After a date has passed it will be removed
+         */
         this.dates = [];
     }
     sortDates() {
@@ -65,4 +72,7 @@ class MuellTonne {
     }
 }
 exports.MuellTonne = MuellTonne;
+/**
+ * The duration of a signle day in milliseconds (used for date calculations)
+ */
 MuellTonne.oneDay = 1000 * 60 * 60 * 24;

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) => {
@@ -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,123 +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 {RoomBase} room - The room to add
+     * @param room - The room to add
      */
     addRoom(room: RoomBase): void;
     /**
      * Adds a device to the database
-     * @param {iBaseDevice} device - The device to add
+     * @param device - The device to add
      */
     addDevice(device: iBaseDevice): void;
     /**
      * Gets the count of the motion sensor today
-     * @param {iMotionSensor} device - The device to get the count for
-     * @returns {Promise<CountToday>} - 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 {iShutter} device - The device to get the last desired position for
-     * @returns {Promise<DesiredShutterPosition>} - 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 {iShutter} device - The device to get the shutter calibration for
-     * @returns {Promise<ShutterCalibration>} - 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 {Promise<void>} - The promise that resolves when the database is initialized
+     * @returns - The promise that resolves when the database is initialized
      */
     initialize(): Promise<void>;
     /**
      * Persists the shutter calibration
-     * @param {ShutterCalibration} data - The shutter calibration data to persist
+     * @param data - The shutter calibration data to persist
      */
     persistShutterCalibration(data: ShutterCalibration): void;
     /**
      * Persists data for an illumination sensor
-     * @param {iIlluminationSensor} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistIlluminationSensor(device: iIlluminationSensor): void;
     /**
      * Persists data for an energy manager
-     * @param {EnergyCalculation} energyData - The energy data to persist
+     * @param energyData - The energy data to persist
      */
     persistEnergyManager(energyData: EnergyCalculation): void;
     /**
      * Persists data of an AC device
-     * @param {iAcDevice} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistAC(device: iAcDevice): void;
     /**
      * Persists data of an actuator
-     * @param {iActuator} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistActuator(device: iActuator): void;
     /**
      * Persists data of a heater
-     * @param {iHeater} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistHeater(device: iHeater): void;
     /**
      * Persists data of a motion sensor
-     * @param {iMotionSensor} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistMotionSensor(device: iMotionSensor): void;
     /**
      * Persists data of a button switch action
-     * @param {iButtonSwitch} device - The device to persist data for
-     * @param {ButtonPressType} pressType - The type of button press
-     * @param {string} buttonName - The name of the button
+     * @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 {iShutter} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistShutter(device: iShutter): void;
     /**
      * Persists data of a temperature sensor
-     * @param {iTemperatureSensor} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistTemperatureSensor(device: iTemperatureSensor): void;
     /**
      * Persists data of a humidity sensor
-     * @param {iHumiditySensor} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistHumiditySensor(device: iHumiditySensor): void;
     /**
      * Persists data of a handle sensor
-     * @param {iHandleSensor} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistHandleSensor(device: iHandleSensor): void;
     /**
      * Persists data of a battery device
-     * @param {iBatteryDevice} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistBatteryDevice(device: iBatteryDevice): void;
     /**
      * Persists data of a Zigbee device
-     * @param {ZigbeeDevice} device - The device to persist data for
+     * @param device - The device to persist data for
      */
     persistZigbeeDevice(device: ZigbeeDevice): void;
     /**
      * Persists settings for the given id
-     * @param {string} id - The id to persist settings for
-     * @param {string} settings - The settings to persist (as JSON string)
-     * @param {string} customname - The custom name of the device/object
+     * @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 {string} id - The id of the object/device to load settings for
-     * @returns {Promise<string | undefined>} - The settings as JSON string or undefined if not found
+     * @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()}');
     `);
     }
+    /** @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-service.d.ts

@@ -1,10 +1,6 @@
 import { OwnGoveeDevice } from './own-govee-device';
-import { Device as GoveeDevice } from '@j3lte/govee-lan-controller';
 export declare class GooveeService {
-    static all: GoveeDevice[];
-    static devicesDict: {
-        [name: string]: GoveeDevice;
-    };
+    private static devicesDict;
     private static goveeApi;
     private static ownDevices;
     static addOwnDevices(gvDevice: {