hoffmation-base 1.0.4 → 1.0.7

package/lib/server/config/iConfig.d.ts

@@ -43,6 +43,11 @@ export interface iConfig {
 export interface iLogSettings {
     logLevel: number;
     useTimestamp: boolean;
+    debugNewMovementState?: boolean;
+    debugShutterPositionChange?: boolean;
+    debugActuatorChange?: boolean;
+    debugUchangedShutterPosition?: boolean;
+    debugUnchangedActuator?: boolean;
 }
 export interface iTimePair {
     hours: number;

package/lib/server/devices/IoBrokerBaseDevice.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="iobroker" />
 import { IBaseDevice } from './baseDeviceInterfaces';
+import { LogDebugType } from '../services';
 import { DeviceInfo } from './DeviceInfo';
 import { LogLevel, RoomBase, RoomDeviceAddingSettings } from '../../models';
 import { IOBrokerConnection } from '../ioBroker';
@@ -37,7 +38,7 @@ export declare abstract class IoBrokerBaseDevice implements IBaseDevice {
      */
     checkIoConnection(showError?: boolean): boolean;
     abstract update(idSplit: string[], state: ioBroker.State, initial: boolean, pOverride: boolean): void;
-    log(level: LogLevel, message: string): void;
+    log(level: LogLevel, message: string, logDebugType?: LogDebugType): void;
     toJSON(): Partial<IoBrokerBaseDevice>;
     protected addToCorrectRoom(): void;
     /**

package/lib/server/devices/IoBrokerBaseDevice.js

@@ -61,11 +61,12 @@ class IoBrokerBaseDevice {
         }
         return this.ioConn !== undefined;
     }
-    log(level, message) {
+    log(level, message, logDebugType = services_1.LogDebugType.None) {
         services_1.ServerLogService.writeLog(level, message, {
             room: this.info.room,
             deviceId: this.id,
             deviceName: this.info.customName,
+            debugType: logDebugType,
         });
     }
     toJSON() {

package/lib/server/devices/hmIPDevices/hmIpLampe.js

@@ -31,7 +31,7 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
     /** @inheritdoc */
     setLight(pValue, timeout = -1, force = false) {
         if (!force && pValue === this.lightOn && this.queuedLightValue === null) {
-            this.log(models_1.LogLevel.DeepTrace, `Skip light command as it is already ${pValue}`);
+            this.log(models_1.LogLevel.DeepTrace, `Skip light command as it is already ${pValue}`, services_1.LogDebugType.SkipUnchangedActuatorCommand);
             return;
         }
         if (this.lightOnSwitchID === '') {
@@ -42,7 +42,7 @@ class HmIpLampe extends hmIpDevice_1.HmIPDevice {
             this.log(models_1.LogLevel.Debug, `Skip automatic command to ${pValue} as it is locked until ${new Date(this.turnOffTime).toLocaleString()}`);
             return;
         }
-        this.log(models_1.LogLevel.Debug, `Lampe schalten Wert: ${pValue}`);
+        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}"`, services_1.LogDebugType.SetActuator);
         this.setState(this.lightOnSwitchID, pValue, undefined, (err) => {
             this.log(models_1.LogLevel.Error, `Lampe schalten ergab Fehler: ${err}`);
         });

package/lib/server/devices/hmIPDevices/hmIpRoll.js

@@ -69,7 +69,7 @@ class HmIpRoll extends hmIpDevice_1.HmIPDevice {
             return;
         }
         if (this.currentLevel === pPosition) {
-            this.log(models_2.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`);
+            this.log(models_2.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`, services_1.LogDebugType.SkipUnchangedRolloPosition);
             return;
         }
         if (this._setLevelSwitchID === '') {

package/lib/server/devices/zigbee/BaseDevices/ZigbeeActuator.js

@@ -37,10 +37,10 @@ class ZigbeeActuator extends zigbeeDevice_1.ZigbeeDevice {
             return;
         }
         if (!force && pValue === this.actuatorOn && this.queuedValue === null) {
-            this.log(models_1.LogLevel.Debug, `Skip actuator command as it is already ${pValue}`);
+            this.log(models_1.LogLevel.Debug, `Skip actuator command as it is already ${pValue}`, services_1.LogDebugType.SkipUnchangedActuatorCommand);
             return;
         }
-        this.log(models_1.LogLevel.Debug, `Switch actuator to: ${pValue}`);
+        this.log(models_1.LogLevel.Debug, `Set outlet Acutator to "${pValue}"`, services_1.LogDebugType.SetActuator);
         this.setState(this.actuatorOnSwitchID, pValue, undefined, (err) => {
             this.log(models_1.LogLevel.Error, `Switching actuator resulted in error: ${err}`);
         });

package/lib/server/devices/zigbee/BaseDevices/zigbeeShutter.js

@@ -70,7 +70,7 @@ class ZigbeeShutter extends zigbeeDevice_1.ZigbeeDevice {
             return;
         }
         if (this.currentLevel === pPosition) {
-            this.log(models_1.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`);
+            this.log(models_1.LogLevel.Debug, `Skip Rollo command to Position ${pPosition} as this is the current one`, services_1.LogDebugType.SkipUnchangedRolloPosition);
             return;
         }
         if (this._fenster !== undefined) {

package/lib/server/devices/zigbee/zigbeeIlluDimmer.js

@@ -88,7 +88,7 @@ class ZigbeeIlluDimmer extends BaseDevices_1.ZigbeeDevice {
         if (pValue && brightness === -1 && this.brightness < 10) {
             brightness = 10;
         }
-        this.log(models_1.LogLevel.Debug, `Dimmer Schalten An: ${pValue} \t Helligkeit: ${brightness}%`);
+        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}" with brightness ${brightness}`, services_1.LogDebugType.SetActuator);
         this.setState(this.stateID, pValue);
         this.queuedValue = pValue;
         if (brightness > -1) {

package/lib/server/devices/zigbee/zigbeeIlluLampe.js

@@ -22,7 +22,7 @@ class ZigbeeIlluLampe extends zigbeeIlluActuator_1.ZigbeeIlluActuator {
     }
     /** @inheritdoc */
     setLight(pValue, timeout = -1, force = false) {
-        this.log(models_1.LogLevel.Debug, `Lampenaktor schalten Wert: ${pValue}`);
+        this.log(models_1.LogLevel.Debug, `Set Light Acutator to "${pValue}"`, services_1.LogDebugType.SetActuator);
         if (this.settings.isStromStoss) {
             timeout = 3000;
             services_1.Utils.guardedTimeout(() => {

package/lib/server/devices/zigbee/zigbeeMotionSensor.js

@@ -53,7 +53,7 @@ class ZigbeeMotionSensor extends BaseDevices_1.ZigbeeDevice {
             return;
         }
         if (newState === this.movementDetected) {
-            this.log(models_1.LogLevel.Debug, `Skip movement because state is already ${newState}`);
+            this.log(models_1.LogLevel.Debug, `Skip movement because state is already ${newState}`, services_1.LogDebugType.SkipUnchangedMovementState);
             if (newState) {
                 // Wenn ein Sensor sich nicht von alleine zurücksetzt, hier erzwingen.
                 this.resetFallbackTimeout();
@@ -63,7 +63,7 @@ class ZigbeeMotionSensor extends BaseDevices_1.ZigbeeDevice {
         }
         this.resetFallbackTimeout();
         this.movementDetected = newState;
-        this.log(models_1.LogLevel.Debug, `New movement state: ${newState}`);
+        this.log(models_1.LogLevel.Debug, `New movement state: ${newState}`, services_1.LogDebugType.NewMovementState);
         if (newState) {
             this.startFallbackTimeout();
             this.detectionsToday++;

package/lib/server/services/Sonos/sonos-service.js

@@ -41,7 +41,7 @@ class SonosService {
                 if (m.from === undefined)
                     return false;
                 SonosService.speakTestMessageOnEachDevice();
-                Telegram_1.TelegramService.sendMessage([m.from.id], 'Testnachricht gesprochen --> Führe weiteren Test durch');
+                Telegram_1.TelegramService.sendMessage([m.chat.id], 'Testnachricht gesprochen --> Führe weiteren Test durch');
                 await SonosService.checkAll();
                 return true;
             }, `Spiele eine kurze Nachricht auf allen Sonos Geräten um diese zu identifizieren`));
@@ -73,6 +73,7 @@ class SonosService {
             for (const deviceName in this.ownDevices) {
                 currentDevice = this.ownDevices[deviceName];
                 if ((currentDevice === null || currentDevice === void 0 ? void 0 : currentDevice.device) === undefined) {
+                    // noinspection ExceptionCaughtLocallyJS
                     throw `${currentDevice === null || currentDevice === void 0 ? void 0 : currentDevice.name} is missing`;
                 }
                 await currentDevice.device.GetState();

package/lib/server/services/Telegram/telegram-Commands.js

@@ -12,7 +12,7 @@ class TelegramCommands {
             if (m.from === undefined)
                 return false;
             room_service_1.RoomService.clearAllAlarms();
-            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Alle ausgelösten Wasser-/Rauchmelder und Eindringlingsalarme wurden gestoppt.');
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], 'Alle ausgelösten Wasser-/Rauchmelder und Eindringlingsalarme wurden gestoppt.');
             return true;
         }, 'Eine Möglichkeit bei Fehlalarm den Alarm abzuschalten'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AwayModeStart', /\/away_mode_start/, async (m) => {
@@ -33,62 +33,62 @@ class TelegramCommands {
             if (m.from === undefined)
                 return false;
             room_service_1.RoomService.endAlarmModes();
-            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Der Abwesenheitsmodus ist deaktiviert.');
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], 'Der Abwesenheitsmodus ist deaktiviert.');
             return true;
         }, 'Alarmanlage nach Abwesenheit/Nacht entschärfen'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('LastMovements', /\/check_movement/, async (m) => {
             if (m.from === undefined)
                 return false;
-            telegram_service_1.TelegramService.sendMessage([m.from.id], `Im Folgenden sind die letzten Bewegungen\n${room_service_1.RoomService.getLastMovements()}`);
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], `Im Folgenden sind die letzten Bewegungen\n${room_service_1.RoomService.getLastMovements()}`);
             return true;
         }, 'Gibt die letzten Bewegungen inkl. ihrer Uhrzeit aus.'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('TelegramTest', /\/test/, async (m) => {
             if (m.from === undefined)
                 return false;
-            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Hallo, ich bin der HoffMation Bot.');
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], 'Hallo, ich bin der HoffMation Bot.');
             return true;
         }, 'Eine Möglichkeit die Verknüpfung mit dem HoffMation Bot zu testen'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('RolloObenCheck', /\/check_rollo/, async (m) => {
             if (m.from === undefined)
                 return false;
-            telegram_service_1.TelegramService.sendMessage([m.from.id], ShutterService_1.ShutterService.getRolladenPosition());
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], ShutterService_1.ShutterService.getRolladenPosition());
             return true;
         }, 'Gibt die Positionen der Rollos aus, warnt über offene Rollos und nennt die nächsten Fahrten'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('FensterCheck', /\/check_fenster/, async (m) => {
             if (m.from === undefined)
                 return false;
-            telegram_service_1.TelegramService.sendMessage([m.from.id], devices_1.Griffe.getGriffPosition());
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], devices_1.Griffe.getGriffPosition());
             return true;
         }, 'Gibt die Positionen der Fenstergriffe aus und warnt somit über offene Fenster'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('BatteryCheck', /\/check_battery/, async (m) => {
             if (m.from === undefined)
                 return Promise.resolve(false);
-            telegram_service_1.TelegramService.sendMessage([m.from.id], devices_1.Devices.getBatteryInfo());
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], devices_1.Devices.getBatteryInfo());
             return Promise.resolve(true);
         }, 'Returns a list of all battery driven devices in ascending order.'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('HeizungCheck', /\/check_temperatur/, async (m) => {
             if (m.from === undefined)
                 return false;
-            telegram_service_1.TelegramService.sendMessage([m.from.id], devices_1.Heizgruppen.getInfo());
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], devices_1.Heizgruppen.getInfo());
             return true;
         }, 'Gibt die Namen und aktuellen Werte sämtlicher Heizgruppen aus (aktuelle Temperatur, Soll Temperatur, Ventilstellung).'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('HeizungError', /\/temperatur_error/, async (m) => {
             if (m.from === undefined)
                 return false;
-            telegram_service_1.TelegramService.sendMessage([m.from.id], devices_1.Heizgruppen.getProblems());
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], devices_1.Heizgruppen.getProblems());
             return true;
         }, 'Zeigt Differenzen zwischen Heizungen und den jeweiligen Heizgruppen auf'));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('HeizungCheckOne', /\/check_1_temperatur.*/, async (m) => {
             if (m.from === undefined)
                 return false;
-            telegram_service_1.TelegramService.sendMessage([m.from.id], await devices_1.Heizgruppen.getSpecificInfo(m.text));
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], await devices_1.Heizgruppen.getSpecificInfo(m.text));
             return true;
         }, `Gibt den Verlauf der in \\"\\" übergebenen Heizgruppe aus.`, /\/check_1_temperatur/));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AllRolloDown', /\/all_rollo_down/, async (m) => {
             if (m.from === undefined)
                 return false;
             room_service_1.RoomService.setAllRolloOfFloor(-1, 0);
-            telegram_service_1.TelegramService.sendMessage([m.from.id], `Es werden alle Rollos heruntergefahren`);
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], `Es werden alle Rollos heruntergefahren`);
             return true;
         }, `Fährt alle rollos runter`));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('VibrationSensitivity', /\/set_vibration_sensitivity/, async (m) => {
@@ -100,7 +100,7 @@ class TelegramCommands {
                     d.setSensitivity(2);
                 }
             }
-            telegram_service_1.TelegramService.sendMessage([m.from.id], 'Abgeschlossen');
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], 'Abgeschlossen');
             return true;
         }, `Setzt alle Vibrationsensoren auf High`));
         telegram_service_1.TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('AllButtonAssignments', /\/get_all_button_assignments/, async (m) => {
@@ -113,7 +113,7 @@ class TelegramCommands {
                     response.push(d.getButtonAssignment());
                 }
             }
-            telegram_service_1.TelegramService.sendMessage([m.from.id], response.join('\n'));
+            telegram_service_1.TelegramService.sendMessage([m.chat.id], response.join('\n'));
             return true;
         }, `Retrieves the button assignments for all buttons in home`));
         if (devices_1.Devices.energymanager !== undefined) {
@@ -128,7 +128,7 @@ class TelegramCommands {
                 response.push(`Drawing Wattage: ${(_d = devices_1.Devices.energymanager) === null || _d === void 0 ? void 0 : _d.drawingWattage}W`);
                 response.push(`Self Consuming Wattage: ${(_e = devices_1.Devices.energymanager) === null || _e === void 0 ? void 0 : _e.selfConsumingWattage}W`);
                 response.push(`Injecting Wattage: ${(_f = devices_1.Devices.energymanager) === null || _f === void 0 ? void 0 : _f.injectingWattage}W`);
-                telegram_service_1.TelegramService.sendMessage([m.from.id], response.join('\n'));
+                telegram_service_1.TelegramService.sendMessage([m.chat.id], response.join('\n'));
                 return true;
             }, `Retrieves the current energy manager values`));
         }

package/lib/server/services/Telegram/telegram-service.js

@@ -46,7 +46,6 @@ class TelegramService {
             log_service_1.ServerLogService.writeLog(models_1.LogLevel.Trace, `Telegram Polling Error stack: ${e.stack}`);
         });
         TelegramService.addMessageCallback(new telegramMessageCalback_1.TelegramMessageCallback('helpCommand', /\/help/, async (m) => {
-            var _a;
             if (m.from === undefined)
                 return true;
             const message = [];
@@ -55,7 +54,7 @@ class TelegramService {
                 const telegramCb = TelegramService.callbacks[cName];
                 message.push(`${telegramCb.identifier.toString().replace(/\//g, '').replace(/\\/g, '')} - ${telegramCb.helpMessage}`);
             }
-            TelegramService.sendMessage([(_a = m.from) === null || _a === void 0 ? void 0 : _a.id], message.join('\n'));
+            TelegramService.sendMessage([m.chat.id], message.join('\n'));
             return true;
         }, `Gibt eine Liste mit sämtlichen Kommandos aus`));
         TelegramService.inform(`(Re-)Initialisierung abgeschlossen`);
@@ -97,7 +96,7 @@ class TelegramService {
     }
     static checkAuthorized(msg) {
         var _a;
-        if (msg.from !== undefined && this.allowedIDs.includes((_a = msg.from) === null || _a === void 0 ? void 0 : _a.id)) {
+        if ((msg.from !== undefined && this.allowedIDs.includes((_a = msg.from) === null || _a === void 0 ? void 0 : _a.id)) || this.allowedIDs.includes(msg.chat.id)) {
             log_service_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Authorisierte Telegram Message erhalten: ${JSON.stringify(msg)}`);
             return true;
         }

package/lib/server/services/ac/daikin-service.js

@@ -31,14 +31,14 @@ class DaikinService {
             if (m.from === undefined)
                 return false;
             DaikinService.setAll(true);
-            Telegram_1.TelegramService.sendMessage([m.from.id], 'Command executed');
+            Telegram_1.TelegramService.sendMessage([m.chat.id], 'Command executed');
             return true;
         }, `Turns all Ac's on without changing any settings`));
         Telegram_1.TelegramService.addMessageCallback(new Telegram_1.TelegramMessageCallback('AcOff', /\/ac_off/, async (m) => {
             if (m.from === undefined)
                 return false;
             DaikinService.setAll(false, true);
-            Telegram_1.TelegramService.sendMessage([m.from.id], 'Command executed');
+            Telegram_1.TelegramService.sendMessage([m.chat.id], 'Command executed');
             return true;
         }, `Turns all Ac's off without changing any settings`));
         return new Promise((res, _rej) => {
@@ -61,6 +61,9 @@ class DaikinService {
         });
     }
     static setAll(on, force = false) {
+        if (!this.isInitialized) {
+            return;
+        }
         for (const deviceName in this._ownDevices) {
             const dev = this._ownDevices[deviceName];
             if (on) {

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

@@ -1,7 +1,14 @@
 import { IBaseDevice } from '../../devices';
 import { RoomBase } from '../../../models';
 import { LogObject } from '../log-service';
+import { OwnDaikinDevice } from '../ac';
 export declare class API {
+    /**
+     * Gets the instance of an Daikin Device identified by name
+     * @param {string} name
+     * @returns {OwnDaikinDevice | undefined}
+     */
+    static getAc(name: string): OwnDaikinDevice | undefined;
     static getDevices(): {
         [id: string]: IBaseDevice;
     };
@@ -9,4 +16,22 @@ export declare class API {
     static getRooms(): Map<string, RoomBase>;
     static getRoom(id: string): RoomBase | undefined;
     static getLog(): LogObject[];
+    /**
+     * Turns on/off one AC identified by it's name
+     * @param name The name of the device, if wrong false will be returned
+     * @param {boolean} desiredState
+     */
+    static setAc(name: string, desiredState: boolean): boolean;
+    /**
+     * Turns on/off all AC´s in the home
+     * @param {boolean} desiredState
+     */
+    static setAllAc(desiredState: boolean): void;
+    /**
+     * Changes the status of a given Lamp
+     * @param {string} deviceId The device Id of the lamp
+     * @param {boolean} state The desired new state
+     * @returns {Error | null} In case it failed the Error containing the reason
+     */
+    static setLight(deviceId: string, state: boolean): Error | null;
 }

package/lib/server/services/api/api-service.js

@@ -5,7 +5,16 @@ const devices_1 = require("../../devices");
 const models_1 = require("../../../models");
 const room_service_1 = require("../room-service");
 const log_service_1 = require("../log-service");
+const ac_1 = require("../ac");
 class API {
+    /**
+     * Gets the instance of an Daikin Device identified by name
+     * @param {string} name
+     * @returns {OwnDaikinDevice | undefined}
+     */
+    static getAc(name) {
+        return ac_1.OwnDaikinDevices.ownDevices[name];
+    }
     static getDevices() {
         // console.log(inspect(Devices.alLDevices, false, 3));
         return devices_1.Devices.alLDevices;
@@ -27,5 +36,48 @@ class API {
     static getLog() {
         return log_service_1.ServerLogService.getLog();
     }
+    /**
+     * Turns on/off one AC identified by it's name
+     * @param name The name of the device, if wrong false will be returned
+     * @param {boolean} desiredState
+     */
+    static setAc(name, desiredState) {
+        const d = this.getAc(name);
+        if (!d) {
+            log_service_1.ServerLogService.writeLog(models_1.LogLevel.Warn, `Daikin Device for name ${name} not found`);
+            return false;
+        }
+        if (desiredState) {
+            d.turnOn();
+        }
+        else {
+            d.deactivateAutomaticTurnOn(60 * 60 * 1000);
+        }
+        return true;
+    }
+    /**
+     * Turns on/off all AC´s in the home
+     * @param {boolean} desiredState
+     */
+    static setAllAc(desiredState) {
+        ac_1.DaikinService.setAll(desiredState, true);
+    }
+    /**
+     * Changes the status of a given Lamp
+     * @param {string} deviceId The device Id of the lamp
+     * @param {boolean} state The desired new state
+     * @returns {Error | null} In case it failed the Error containing the reason
+     */
+    static setLight(deviceId, state) {
+        const d = this.getDevice(deviceId);
+        if (d === undefined) {
+            return new Error(`Device with ID ${deviceId} not found`);
+        }
+        if (typeof d.setLight !== 'function') {
+            return new Error(`Device with ID ${deviceId} is no Lamp`);
+        }
+        d.setLight(state, 60 * 60 * 1000, true);
+        return null;
+    }
 }
 exports.API = API;

package/lib/server/services/log-service/log-filter-data.d.ts

@@ -1,8 +1,18 @@
 import { LogSource } from '../../../models/logSource';
+export declare enum LogDebugType {
+    None = 0,
+    SkipUnchangedActuatorCommand = 1,
+    SkipUnchangedRolloPosition = 2,
+    SetActuator = 3,
+    ShutterPositionChange = 4,
+    NewMovementState = 5,
+    SkipUnchangedMovementState = 6
+}
 export declare class LogFilterData {
     room?: string;
     deviceId?: string;
     deviceName?: string;
     groupType?: string;
     source?: LogSource;
+    debugType?: LogDebugType;
 }

package/lib/server/services/log-service/log-filter-data.js

@@ -1,6 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogFilterData = void 0;
+exports.LogFilterData = exports.LogDebugType = void 0;
+var LogDebugType;
+(function (LogDebugType) {
+    LogDebugType[LogDebugType["None"] = 0] = "None";
+    LogDebugType[LogDebugType["SkipUnchangedActuatorCommand"] = 1] = "SkipUnchangedActuatorCommand";
+    LogDebugType[LogDebugType["SkipUnchangedRolloPosition"] = 2] = "SkipUnchangedRolloPosition";
+    LogDebugType[LogDebugType["SetActuator"] = 3] = "SetActuator";
+    LogDebugType[LogDebugType["ShutterPositionChange"] = 4] = "ShutterPositionChange";
+    LogDebugType[LogDebugType["NewMovementState"] = 5] = "NewMovementState";
+    LogDebugType[LogDebugType["SkipUnchangedMovementState"] = 6] = "SkipUnchangedMovementState";
+})(LogDebugType = exports.LogDebugType || (exports.LogDebugType = {}));
 class LogFilterData {
+    constructor() {
+        this.debugType = LogDebugType.None;
+    }
 }
 exports.LogFilterData = LogFilterData;

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

@@ -15,4 +15,10 @@ export declare class ServerLogService {
     static addedDeviceToRoom(pRoomName: string, pDeviceType: DeviceType, pRoomIndex: number, forceDebug?: boolean): void;
     static missingRoomHandling(pRoomName: string, pDeviceType: DeviceType): void;
     static missingRoomIndexHandling(pRoomName: string, pIndex: number, pDeviceType: DeviceType): void;
+    /**
+     * Checks if this message is of a debugtype which should be skipped according to settings
+     * @param {LogDebugType} debugType
+     * @returns {boolean} If the Message should be skipped
+     */
+    private static checkDebugLogSkip;
 }

package/lib/server/services/log-service/log-service.js

@@ -6,7 +6,9 @@ const models_1 = require("../../../models");
 const devices_1 = require("../../devices");
 const utils_1 = require("../utils");
 const log_object_1 = require("./log-object");
+const log_filter_data_1 = require("./log-filter-data");
 const logSource_1 = require("../../../models/logSource");
+const settings_service_1 = require("../settings-service");
 class ServerLogService {
     static getLog(amount = 5000) {
         return this.storage.readAmount(amount);
@@ -17,6 +19,9 @@ class ServerLogService {
     static writeLog(pLevel, pMessage, additionalLogInfo) {
         var _a;
         const now = Date.now();
+        if ((additionalLogInfo === null || additionalLogInfo === void 0 ? void 0 : additionalLogInfo.debugType) !== undefined && ServerLogService.checkDebugLogSkip(additionalLogInfo.debugType)) {
+            return;
+        }
         if (pLevel > this.storageLevel && pLevel > ServerLogService.settings.logLevel) {
             return;
         }
@@ -53,6 +58,46 @@ class ServerLogService {
     static missingRoomIndexHandling(pRoomName, pIndex, pDeviceType) {
         ServerLogService.writeLog(models_1.LogLevel.Warn, `Raum "${pRoomName}" hat keine Definition für den Typ "${devices_1.DeviceType[pDeviceType]} mit Index ${pIndex}"`);
     }
+    /**
+     * Checks if this message is of a debugtype which should be skipped according to settings
+     * @param {LogDebugType} debugType
+     * @returns {boolean} If the Message should be skipped
+     */
+    static checkDebugLogSkip(debugType) {
+        var _a, _b, _c, _d, _e;
+        switch (debugType) {
+            case log_filter_data_1.LogDebugType.None:
+                break;
+            case log_filter_data_1.LogDebugType.SkipUnchangedActuatorCommand:
+                if (((_a = settings_service_1.SettingsService.settings.logSettings) === null || _a === void 0 ? void 0 : _a.debugUnchangedActuator) === true) {
+                    return false;
+                }
+                break;
+            case log_filter_data_1.LogDebugType.SkipUnchangedRolloPosition:
+                if (((_b = settings_service_1.SettingsService.settings.logSettings) === null || _b === void 0 ? void 0 : _b.debugUchangedShutterPosition) === true) {
+                    return false;
+                }
+                break;
+            case log_filter_data_1.LogDebugType.SetActuator:
+                if (((_c = settings_service_1.SettingsService.settings.logSettings) === null || _c === void 0 ? void 0 : _c.debugActuatorChange) === true) {
+                    return false;
+                }
+                break;
+            case log_filter_data_1.LogDebugType.ShutterPositionChange:
+                if (((_d = settings_service_1.SettingsService.settings.logSettings) === null || _d === void 0 ? void 0 : _d.debugShutterPositionChange) === true) {
+                    return false;
+                }
+                break;
+            case log_filter_data_1.LogDebugType.NewMovementState:
+                if (((_e = settings_service_1.SettingsService.settings.logSettings) === null || _e === void 0 ? void 0 : _e.debugNewMovementState) === true) {
+                    return false;
+                }
+                break;
+            case log_filter_data_1.LogDebugType.SkipUnchangedMovementState:
+                break;
+        }
+        return true;
+    }
 }
 exports.ServerLogService = ServerLogService;
 ServerLogService.telegramLevel = -1; // Controlled from within Config File

package/lib/server/services/utils/utils.js

@@ -76,7 +76,7 @@ class Utils {
     }
     static jsonFilter(object) {
         return lodash_1.default.omit(object, Object.keys(object).filter((key) => {
-            if (key.includes('Timeout') || key.includes('Interval')) {
+            if (key.includes('Timeout') || key.includes('Interval') || key.includes('timeouts')) {
                 // Exclude timeout Variables.
                 return true;
             }