hoffmation-base 0.1.33 → 0.1.35

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

@@ -12,6 +12,8 @@ class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
     constructor(pInfo, deviceType) {
         super(pInfo, deviceType);
         this.position = MagnetPosition_1.MagnetPosition.closed;
+        this.telegramOnOpen = false;
+        this.speakOnOpen = false;
         this._closedCallback = [];
         this._openCallback = [];
         this.minutesOpen = 0;
@@ -46,7 +48,9 @@ class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
                 }
                 // const message: string = `Die Tür wurde nach ${this.minutesOpen} Minuten geschlossen!`;
                 this.log(logLevel_1.LogLevel.Info, message);
-                telegram_service_1.TelegramService.inform(message);
+                if (this.telegramOnOpen) {
+                    telegram_service_1.TelegramService.inform(message);
+                }
                 this.minutesOpen = 0;
                 this._iOpenTimeout = undefined;
             }
@@ -54,8 +58,12 @@ class ZigbeeMagnetContact extends zigbeeDevice_1.ZigbeeDevice {
         }
         else if (this._iOpenTimeout === undefined) {
             const message = res_1.Res.wasOpened(this.info.customName);
-            telegram_service_1.TelegramService.inform(message);
-            sonos_service_1.SonosService.speakOnAll(message, 40);
+            if (this.telegramOnOpen) {
+                telegram_service_1.TelegramService.inform(message);
+            }
+            if (this.speakOnOpen) {
+                sonos_service_1.SonosService.speakOnAll(message, 40);
+            }
             this._iOpenTimeout = utils_1.Utils.guardedInterval(() => {
                 this.minutesOpen++;
                 const message = `Contact is  ${MagnetPosition_1.MagnetPosition[this.position]} since ${this.minutesOpen} minutes`;

package/lib/server/devices/zigbee/zigbeeSonoffTemp.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="iobroker" />
+import { ZigbeeDevice } from './zigbeeDevice';
+import { iTemperaturSensor } from '../iTemperaturSensor';
+import { iHumiditySensor } from '../iHumiditySensor';
+import { DeviceInfo } from '../DeviceInfo';
+export declare class ZigbeeSonoffTemp extends ZigbeeDevice implements iTemperaturSensor, iHumiditySensor {
+    private _humidity;
+    private _humidityCallbacks;
+    private _temperatur;
+    constructor(pInfo: DeviceInfo);
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    get humidity(): number;
+    private set humidity(value);
+    get iTemperatur(): number;
+    get sTemperatur(): string;
+    addHumidityCallback(pCallback: (pValue: number) => void): void;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeSonoffTemp = void 0;
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const deviceType_1 = require("../deviceType");
+class ZigbeeSonoffTemp extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo) {
+        super(pInfo, deviceType_1.DeviceType.ZigbeeSonoffTemp);
+        this._humidity = -99;
+        this._humidityCallbacks = [];
+        this._temperatur = -99;
+    }
+    update(idSplit, state, initial = false) {
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'humidity':
+                this.humidity = state.val;
+                break;
+            case 'temperatur':
+                this._temperatur = state.val;
+                break;
+        }
+    }
+    get humidity() {
+        return this._humidity;
+    }
+    set humidity(val) {
+        this._humidity = val;
+        for (const cb of this._humidityCallbacks) {
+            cb(val);
+        }
+    }
+    get iTemperatur() {
+        return this._temperatur;
+    }
+    get sTemperatur() {
+        return `${this._temperatur}°C`;
+    }
+    addHumidityCallback(pCallback) {
+        this._humidityCallbacks.push(pCallback);
+        if (this._humidity > 0) {
+            pCallback(this._humidity);
+        }
+    }
+}
+exports.ZigbeeSonoffTemp = ZigbeeSonoffTemp;

package/lib/server/services/Sonos/polly-service.d.ts

@@ -6,7 +6,7 @@ export declare class PollyService {
     static polly: AWS.Polly;
     static voice: string;
     static initialize(config: iPollySettings): void;
-    static getDuration(name: string): number;
+    static getDuration(filename: string): number;
     static preloadTTS(text: string): void;
     static tts(text: string, cb: (fileLink: string, duration: number) => void): void;
 }

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

@@ -31,6 +31,7 @@ const get_mp3_duration_1 = __importDefault(require("get-mp3-duration"));
 const crypto_1 = __importDefault(require("crypto"));
 const log_service_1 = require("../log-service/log-service");
 const logLevel_1 = require("../../../models/logLevel");
+const path_1 = __importDefault(require("path"));
 class PollyService {
     static initialize(config) {
         this.active = true;
@@ -45,8 +46,8 @@ class PollyService {
         });
         this.voice = config.voiceID;
     }
-    static getDuration(name) {
-        const fPath = this._mp3Path + name + '.mp3';
+    static getDuration(filename) {
+        const fPath = path_1.default.join(this._mp3Path, filename);
         try {
             if (fs.existsSync(fPath)) {
                 const duration = (0, get_mp3_duration_1.default)(fs.readFileSync(fPath));

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

@@ -2,5 +2,11 @@ import { HTTPSOptions } from './HTTPSOptions';
 export declare class HTTPSService {
     private static defaultCallback;
     static request(options: HTTPSOptions, postData?: string, retryOnError?: number, responseCallback?: (data: string, statuscode: number) => void): void;
+    /**
+     * Downloads a file from a given url to the given location.
+     * If the location doesn't exist, it will be created quietly.
+     * @param url URL to download file from
+     * @param filePath Path to save file to
+     */
     static downloadFile(url: string, filePath: string): Promise<boolean>;
 }

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

@@ -28,6 +28,7 @@ const https_1 = __importDefault(require("https"));
 const log_service_1 = require("./log-service/log-service");
 const utils_1 = require("./utils/utils");
 const logLevel_1 = require("../../models/logLevel");
+const path_1 = __importDefault(require("path"));
 class HTTPSService {
     static defaultCallback(data, statuscode) {
         log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Response statusCode:"${statuscode}"\nData:"${data}"`);
@@ -59,8 +60,19 @@ class HTTPSService {
         }
         req.end();
     }
+    /**
+     * Downloads a file from a given url to the given location.
+     * If the location doesn't exist, it will be created quietly.
+     * @param url URL to download file from
+     * @param filePath Path to save file to
+     */
     static async downloadFile(url, filePath) {
         return new Promise((resolve, reject) => {
+            // if directory structure doesn't exist yet, create it
+            const fileDir = path_1.default.dirname(filePath);
+            if (!fs.existsSync(fileDir)) {
+                fs.mkdirSync(fileDir, { recursive: true });
+            }
             const file = fs.createWriteStream(filePath);
             let fileInfo = null;
             const request = https_1.default.get(url, (response) => {

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

@@ -1,6 +1,8 @@
+import { LogSource } from '../../../models/logSource';
 export declare class LogFilterData {
     room?: string;
     deviceId?: string;
     deviceName?: string;
     groupType?: string;
+    source?: LogSource;
 }

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

@@ -6,6 +6,7 @@ const logLevel_1 = require("../../../models/logLevel");
 const deviceType_1 = require("../../devices/deviceType");
 const ringstorage_1 = require("../utils/ringstorage");
 const log_object_1 = require("./log-object");
+const logSource_1 = require("../../../models/logSource");
 class ServerLogService {
     static getLog(amount = 5000) {
         return this.storage.readAmount(amount);
@@ -14,6 +15,7 @@ class ServerLogService {
         this.settings = logSettings;
     }
     static writeLog(pLevel, pMessage, additionalLogInfo) {
+        var _a;
         const now = Date.now();
         if (pLevel > this.storageLevel && pLevel > ServerLogService.settings.logLevel) {
             return;
@@ -29,6 +31,10 @@ class ServerLogService {
             else if (additionalLogInfo === null || additionalLogInfo === void 0 ? void 0 : additionalLogInfo.room) {
                 message += `"${additionalLogInfo.room}": `;
             }
+            const logSource = (_a = additionalLogInfo === null || additionalLogInfo === void 0 ? void 0 : additionalLogInfo.source) !== null && _a !== void 0 ? _a : 0;
+            if (logSource > 0) {
+                message += `${logSource_1.LogSource[logSource]}: `;
+            }
             message += pMessage;
             console.log(message);
             if (pLevel <= ServerLogService.telegramLevel) {

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

@@ -1,10 +1,40 @@
 import { OwnSonosDevice } from './Sonos/sonos-service';
+import { iNewsSettings } from '../config/iConfig';
 export declare class NewsService {
-    static oneDay: number;
-    static lastNewsName: string;
-    private static hourlyInterval;
-    static initialize(): void;
+    static lastNewsAudioFile: string;
+    private static interval;
+    private static requestInterval;
+    private static keepMaxAge;
+    private static rssUrl;
+    private static lastFetchedPubDate;
+    static initialize(config?: Partial<iNewsSettings>): void;
+    /**
+     * Stops the regular check for new news feed items.
+     * @deprecated Use stopInterval instead
+     */
     static stopHourlyInterval(): void;
-    static getLastNews(): void;
+    static startInterval(): void;
+    /**
+     * Stops the regular check for new news feed items.
+     */
+    static stopInterval(): void;
+    /**
+     * Checks if there are newer news than the one currently available on disk and downloads the file for playing.
+     */
+    static getLatestNews(): void;
+    private static downloadLatestFileFromFeed;
+    /**
+     * Deletes all files in the given directory that are older than the given age.
+     * @param rootDir Directory to search in
+     * @param keepMaxAge Maximum age in minutes until a file gets deleted
+     * @private
+     */
+    private static cleanOldFiles;
+    /**
+     * Plays the latest news on a sonos device
+     * @param ownSonosDevice Sonos device to play from
+     * @param volume volume to play at
+     * @param retries Number of times playing should be tried if there is currently no audio file available
+     */
     static playLastNews(ownSonosDevice: OwnSonosDevice, volume?: number, retries?: number): void;
 }

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

@@ -18,6 +18,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NewsService = void 0;
 const fs = __importStar(require("fs"));
@@ -27,68 +30,164 @@ const log_service_1 = require("./log-service/log-service");
 const sonos_service_1 = require("./Sonos/sonos-service");
 const polly_service_1 = require("./Sonos/polly-service");
 const settings_service_1 = require("./settings-service");
-const HTTPSOptions_1 = require("./HTTPSOptions");
 const logLevel_1 = require("../../models/logLevel");
+const path_1 = __importDefault(require("path"));
+const rss_parser_1 = __importDefault(require("rss-parser"));
+const logSource_1 = require("../../models/logSource");
 class NewsService {
-    static initialize() {
-        NewsService.hourlyInterval = utils_1.Utils.guardedInterval(NewsService.getLastNews, 3600000);
-        NewsService.getLastNews();
+    static initialize(config) {
+        var _a, _b;
+        if (config === undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Service disabled.`, { source: logSource_1.LogSource.News });
+            return;
+        }
+        NewsService.keepMaxAge = (_a = config.keepMaxAge) !== null && _a !== void 0 ? _a : 120;
+        NewsService.requestInterval = (_b = config.requestInterval) !== null && _b !== void 0 ? _b : 30;
+        NewsService.rssUrl = config.rssUrl;
+        NewsService.startInterval();
     }
+    /**
+     * Stops the regular check for new news feed items.
+     * @deprecated Use stopInterval instead
+     */
     static stopHourlyInterval() {
-        if (this.hourlyInterval !== undefined) {
-            clearInterval(this.hourlyInterval);
-            this.hourlyInterval = undefined;
+        NewsService.stopInterval();
+    }
+    static startInterval() {
+        var _a;
+        if (NewsService.interval !== undefined) {
+            clearInterval(NewsService.interval);
+        }
+        NewsService.interval = utils_1.Utils.guardedInterval(() => {
+            NewsService.getLatestNews();
+        }, ((_a = NewsService.requestInterval) !== null && _a !== void 0 ? _a : 30) * 60 * 1000, undefined, true);
+    }
+    /**
+     * Stops the regular check for new news feed items.
+     */
+    static stopInterval() {
+        if (NewsService.interval === undefined) {
+            return;
         }
+        clearInterval(NewsService.interval);
+        NewsService.interval = undefined;
     }
-    static getLastNews() {
-        https_service_1.HTTPSService.request(new HTTPSOptions_1.HTTPSOptions('www1.wdr.de', '/mediathek/audio/wdr-aktuell-news/index.html', {}, 'GET', 443), '', 5, (response) => {
-            var _a;
+    /**
+     * Checks if there are newer news than the one currently available on disk and downloads the file for playing.
+     */
+    static getLatestNews() {
+        if (settings_service_1.SettingsService.settings.mp3Server === undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Not checking for newest news file, no download directory defined.`, {
+                source: logSource_1.LogSource.News,
+            });
+            return;
+        }
+        NewsService.cleanOldFiles(settings_service_1.SettingsService.settings.mp3Server.path, NewsService.keepMaxAge);
+        if (NewsService.rssUrl === undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `No rss feed set, not searching for new news.`, {
+                source: logSource_1.LogSource.News,
+            });
+            return;
+        }
+        NewsService.downloadLatestFileFromFeed(NewsService.rssUrl, settings_service_1.SettingsService.settings.mp3Server.path);
+    }
+    static downloadLatestFileFromFeed(rssUrl, targetDir) {
+        const parser = new rss_parser_1.default();
+        parser.parseURL(rssUrl).then((feed) => {
             try {
-                const cutAfterDownload = response.split(`" title="Audio Download">`)[0];
-                const cutsPriorDownload = cutAfterDownload.split(`<a class="button download " href="`);
-                const target = 'https:' + cutsPriorDownload[cutsPriorDownload.length - 1];
-                const splits = target.split('/');
-                const fileName = splits[splits.length - 1];
-                const filePath = `${(_a = settings_service_1.SettingsService.settings.mp3Server) === null || _a === void 0 ? void 0 : _a.path}${fileName}`;
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `NewsService: Die aktuelle News ist "${target}"`);
-                if (fs.existsSync(filePath)) {
-                    NewsService.lastNewsName = fileName.split('.mp3')[0];
-                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Wir haben bereits die neuste WDR Nachrichten heruntergeladen.`);
+                const currentFeedItem = feed.items[0];
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Most recent news on ${feed.title} is "${currentFeedItem.title}"`);
+                if (currentFeedItem.enclosure === undefined) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Couldn't find audio in last item of the rss feed.`, {
+                        source: logSource_1.LogSource.News,
+                    });
                     return;
                 }
-                https_service_1.HTTPSService.downloadFile(target, filePath)
+                const filePath = path_1.default.join(targetDir, path_1.default.basename(currentFeedItem.enclosure.url));
+                // check for both path and pubdate in case the file name is always the same one
+                if (fs.existsSync(filePath) && NewsService.lastFetchedPubDate == currentFeedItem.pubDate) {
+                    NewsService.lastNewsAudioFile = path_1.default.basename(filePath);
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Newest file already downloaded.`, { source: logSource_1.LogSource.News });
+                    return;
+                }
+                https_service_1.HTTPSService.downloadFile(currentFeedItem.enclosure.url, filePath)
                     .then((success) => {
                     if (!success) {
-                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fehler beim Herunterladen der Nachrichten von WDR`);
+                        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Error while downloading audio file.`, {
+                            source: logSource_1.LogSource.News,
+                        });
                         return;
                     }
-                    NewsService.lastNewsName = fileName.split('.mp3')[0];
+                    NewsService.lastNewsAudioFile = path_1.default.basename(filePath);
                 })
                     .catch((reason) => {
-                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Fehler beim Herunterladen der WDR Antwort Error: ${reason.message}`);
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Error while downloading feed audio: ${reason.message}`, {
+                        source: logSource_1.LogSource.News,
+                    });
                 });
             }
             catch (e) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Fehler beim Parsen der WDR Antwort Error: ${e}`);
-                return;
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Error while parsing feed: ${e}`, { source: logSource_1.LogSource.News });
             }
         });
     }
+    /**
+     * Deletes all files in the given directory that are older than the given age.
+     * @param rootDir Directory to search in
+     * @param keepMaxAge Maximum age in minutes until a file gets deleted
+     * @private
+     */
+    static cleanOldFiles(rootDir, keepMaxAge) {
+        let deleteCount = 0;
+        fs.readdir(rootDir, (err, files) => {
+            if (err)
+                return;
+            files.forEach((file) => {
+                fs.stat(path_1.default.join(rootDir, file), (err, stat) => {
+                    if (err)
+                        return;
+                    const now = new Date().getTime();
+                    const maxSurvivingTime = new Date(stat.ctime).getTime() + keepMaxAge * 60 * 1000;
+                    if (now <= maxSurvivingTime) {
+                        return;
+                    }
+                    fs.unlink(path_1.default.join(rootDir, file), (err) => {
+                        if (err) {
+                            return console.error(err);
+                        }
+                        deleteCount++;
+                    });
+                });
+            });
+        });
+        if (deleteCount > 0) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Deleted ${deleteCount} old file/s.`, { source: logSource_1.LogSource.News });
+        }
+    }
+    /**
+     * Plays the latest news on a sonos device
+     * @param ownSonosDevice Sonos device to play from
+     * @param volume volume to play at
+     * @param retries Number of times playing should be tried if there is currently no audio file available
+     */
     static playLastNews(ownSonosDevice, volume = 30, retries = 5) {
-        if (!NewsService.lastNewsName) {
+        if (!NewsService.lastNewsAudioFile) {
             if (retries > 0) {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Der NewsService ist noch nicht bereit --> warten, verbleibende Neuversuche ${retries - 1}`);
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Warn, `Service not ready yet --> waiting, remaining tries: ${retries - 1}`, {
+                    source: logSource_1.LogSource.News,
+                });
                 utils_1.Utils.guardedTimeout(() => {
                     NewsService.playLastNews(ownSonosDevice, volume, retries - 1);
                 }, 1000);
             }
             else {
-                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Der NewsService ist trotz Warten nicht bereit --> Abbruch`);
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Service not ready despite waiting --> Abort.`, {
+                    source: logSource_1.LogSource.News,
+                });
             }
             return;
         }
-        sonos_service_1.SonosService.playOnDevice(ownSonosDevice, NewsService.lastNewsName, polly_service_1.PollyService.getDuration(NewsService.lastNewsName), volume);
+        sonos_service_1.SonosService.playOnDevice(ownSonosDevice, path_1.default.basename(NewsService.lastNewsAudioFile, path_1.default.extname(NewsService.lastNewsAudioFile)), polly_service_1.PollyService.getDuration(NewsService.lastNewsAudioFile), volume);
     }
 }
 exports.NewsService = NewsService;
-NewsService.oneDay = 1000 * 60 * 60 * 24;