hoffmation-base 0.1.14 → 0.1.18

package/lib/server/ioBroker/index.d.ts

@@ -0,0 +1,6 @@
+export * from './connection';
+export * from './ioBroker.main';
+export * from './socketIOLogging';
+export * from './socketIOAuthInfo';
+export * from './socketIOVisCommand';
+export * from './socketIOConnectOptions';

package/lib/server/ioBroker/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./connection"), exports);
+__exportStar(require("./ioBroker.main"), exports);
+__exportStar(require("./socketIOLogging"), exports);
+__exportStar(require("./socketIOAuthInfo"), exports);
+__exportStar(require("./socketIOVisCommand"), exports);
+__exportStar(require("./socketIOConnectOptions"), exports);

package/lib/server/ioBroker/ioBroker.main.d.ts

@@ -0,0 +1,15 @@
+import { DeviceUpdater } from '../devices/deviceUpdater';
+import { RoomBase } from '../../models/rooms/RoomBase';
+export declare class ioBrokerMain {
+    private static roomConstructors;
+    private servConn;
+    private deviceUpdater;
+    private states;
+    private connectionCallbacks;
+    static addRoomConstructor(roomName: string, constr: {
+        new (): RoomBase;
+    }): void;
+    constructor(pDeviceUpdater: DeviceUpdater);
+    private static initRooms;
+    private initConnCallbacks;
+}

package/lib/server/ioBroker/ioBroker.main.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ioBrokerMain = void 0;
+const logLevel_1 = require("../../models/logLevel");
+const devices_1 = require("../devices/devices");
+const log_service_1 = require("../services/log-service");
+const time_callback_service_1 = require("../services/time-callback-service");
+const connection_1 = require("./connection");
+const connectionCallbacks_1 = require("../../models/connectionCallbacks");
+const utils_1 = require("../services/utils/utils");
+const settings_service_1 = require("../services/settings-service");
+class ioBrokerMain {
+    constructor(pDeviceUpdater) {
+        this.states = {};
+        this.deviceUpdater = pDeviceUpdater;
+        this.connectionCallbacks = new connectionCallbacks_1.ConnectionCallbacks();
+        this.initConnCallbacks();
+        this.servConn = new connection_1.IOBrokerConnection({
+            name: '',
+            connLink: settings_service_1.SettingsService.settings.ioBrokerUrl,
+            socketSession: '', // optional - used by authentication
+        }, this.connectionCallbacks);
+        devices_1.Devices.addIoConnection(this.servConn);
+        ioBrokerMain.initRooms();
+    }
+    static addRoomConstructor(roomName, constr) {
+        if (ioBrokerMain.roomConstructors[roomName] !== undefined) {
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Konstruktor für Raum mit Namen "${roomName}" bereits hinzugefügt`);
+            return;
+        }
+        ioBrokerMain.roomConstructors[roomName] = constr;
+    }
+    static initRooms() {
+        for (const key in ioBrokerMain.roomConstructors) {
+            new ioBrokerMain.roomConstructors[key]();
+        }
+    }
+    initConnCallbacks() {
+        this.connectionCallbacks.onObjectChange = (pId, pObj) => {
+            utils_1.Utils.guardedNewThread(() => {
+                this.deviceUpdater.updateObject(pId, pObj);
+            }, this);
+        };
+        this.connectionCallbacks.onConnChange = (isConnected) => {
+            if (!isConnected) {
+                console.log('disconnected');
+                return;
+            }
+            console.log('connected');
+            this.servConn.getStates(null, (err, _states) => {
+                if (err !== null && err !== undefined) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Info, `Iobroker Error: ${err.message}\n${err.stack}`);
+                }
+                if (_states === undefined) {
+                    return;
+                }
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Im initialen GetStates Callback`);
+                let count = 0;
+                for (const id in _states) {
+                    this.deviceUpdater.updateState(id, _states[id], true);
+                    count++;
+                }
+                console.log('Received ' + count + ' states.');
+                this.states = _states;
+                time_callback_service_1.TimeCallbackService.performCheck();
+                time_callback_service_1.TimeCallbackService.performCheck();
+            });
+        };
+        this.connectionCallbacks.onRefresh = () => {
+            //
+        };
+        this.connectionCallbacks.onUpdate = (id, state) => {
+            utils_1.Utils.guardedNewThread(() => {
+                // console.log('NEW VALUE of ' + id + ': ' + JSON.stringify(state));
+                this.states[id] = state;
+                this.deviceUpdater.updateState(id, state);
+            }, this);
+        };
+        this.connectionCallbacks.onError = (err) => {
+            console.log(`Cannot execute ${err.command} for ${err.arg}, because of insufficient permissions`);
+        };
+    }
+}
+exports.ioBrokerMain = ioBrokerMain;
+ioBrokerMain.roomConstructors = {};

package/lib/server/ioBroker/socketIOAuthInfo.d.ts

@@ -0,0 +1,5 @@
+export declare class SocketIOAuthInfo {
+    user: any;
+    hash: any;
+    salt: any;
+}

package/lib/server/ioBroker/socketIOAuthInfo.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIOAuthInfo = void 0;
+class SocketIOAuthInfo {
+}
+exports.SocketIOAuthInfo = SocketIOAuthInfo;

package/lib/server/ioBroker/socketIOConnectOptions.d.ts

@@ -0,0 +1,6 @@
+export declare class SocketIOConnectOpts {
+    name?: string;
+    connLink?: any;
+    socketSession?: any;
+    socketForceWebSockets?: boolean;
+}

package/lib/server/ioBroker/socketIOConnectOptions.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIOConnectOpts = void 0;
+class SocketIOConnectOpts {
+}
+exports.SocketIOConnectOpts = SocketIOConnectOpts;

package/lib/server/ioBroker/socketIOLogging.d.ts

@@ -0,0 +1,12 @@
+export declare class SocketIoLogging {
+    static LogLevel: number;
+    static writeLog(pLevel: SocketIoLogLevel, pMessage: string): void;
+}
+export declare enum SocketIoLogLevel {
+    Error = 1,
+    Warn = 2,
+    Info = 3,
+    Debug = 4,
+    Trace = 5,
+    DeepTrace = 6
+}

package/lib/server/ioBroker/socketIOLogging.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIoLogLevel = exports.SocketIoLogging = void 0;
+class SocketIoLogging {
+    static writeLog(pLevel, pMessage) {
+        if (pLevel > SocketIoLogging.LogLevel) {
+            return;
+        }
+        switch (pLevel) {
+            case SocketIoLogLevel.Error:
+                console.error(pMessage);
+                break;
+            case SocketIoLogLevel.Error:
+                console.warn(pMessage);
+                break;
+            default:
+                console.log(pMessage);
+                break;
+        }
+    }
+}
+exports.SocketIoLogging = SocketIoLogging;
+SocketIoLogging.LogLevel = 5;
+var SocketIoLogLevel;
+(function (SocketIoLogLevel) {
+    SocketIoLogLevel[SocketIoLogLevel["Error"] = 1] = "Error";
+    SocketIoLogLevel[SocketIoLogLevel["Warn"] = 2] = "Warn";
+    SocketIoLogLevel[SocketIoLogLevel["Info"] = 3] = "Info";
+    SocketIoLogLevel[SocketIoLogLevel["Debug"] = 4] = "Debug";
+    SocketIoLogLevel[SocketIoLogLevel["Trace"] = 5] = "Trace";
+    SocketIoLogLevel[SocketIoLogLevel["DeepTrace"] = 6] = "DeepTrace";
+})(SocketIoLogLevel = exports.SocketIoLogLevel || (exports.SocketIoLogLevel = {}));

package/lib/server/ioBroker/socketIOVisCommand.d.ts

@@ -0,0 +1,6 @@
+export declare class SocketIOVisCommand {
+    command: string;
+    data: string;
+    instance: string;
+    constructor(pObject: any);
+}

package/lib/server/ioBroker/socketIOVisCommand.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIOVisCommand = void 0;
+class SocketIOVisCommand {
+    constructor(pObject) {
+        this.command = pObject.command;
+        this.data = pObject.data;
+        this.instance = pObject.instance;
+    }
+}
+exports.SocketIOVisCommand = SocketIOVisCommand;

package/lib/server/services/HTTPSOptions.d.ts

@@ -0,0 +1,12 @@
+export declare class HTTPSOptions {
+    hostname: string;
+    path: string;
+    headers: {
+        [id: string]: string;
+    };
+    method: string;
+    port: number;
+    constructor(hostname: string, path: string, headers?: {
+        [id: string]: string;
+    }, method?: string, port?: number);
+}

package/lib/server/services/HTTPSOptions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPSOptions = void 0;
+const log_service_1 = require("./log-service");
+const logLevel_1 = require("../../models/logLevel");
+class HTTPSOptions {
+    constructor(hostname, path, headers = {}, method = 'POST', port = 443) {
+        this.hostname = hostname;
+        this.path = path;
+        this.headers = headers;
+        this.method = method;
+        this.port = port;
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `${method} Request at '${hostname}' for '${path}'`);
+    }
+}
+exports.HTTPSOptions = HTTPSOptions;

package/lib/server/services/Sonos/OwnSonosDevices.d.ts

@@ -0,0 +1,7 @@
+import { OwnSonosDevice } from './sonos-service';
+export declare class OwnSonosDevices {
+    static ownDevices: {
+        [name: string]: OwnSonosDevice;
+    };
+    static addDevice(device: OwnSonosDevice): void;
+}

package/lib/server/services/Sonos/OwnSonosDevices.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnSonosDevices = void 0;
+class OwnSonosDevices {
+    static addDevice(device) {
+        this.ownDevices[device.name] = device;
+    }
+}
+exports.OwnSonosDevices = OwnSonosDevices;
+OwnSonosDevices.ownDevices = {};

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

@@ -0,0 +1,4 @@
+export * from './mp3-server';
+export * from './polly-service';
+export * from './sonos-service';
+export * from './OwnSonosDevices';

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

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./mp3-server"), exports);
+__exportStar(require("./polly-service"), exports);
+__exportStar(require("./sonos-service"), exports);
+__exportStar(require("./OwnSonosDevices"), exports);

package/lib/server/services/Sonos/mp3-server.d.ts

@@ -0,0 +1,7 @@
+import { iMp3Settings } from '../../config/iConfig';
+export declare class MP3Server {
+    static active: boolean;
+    count: number;
+    private mp3Path;
+    constructor(settings: iMp3Settings);
+}

package/lib/server/services/Sonos/mp3-server.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MP3Server = void 0;
+const http = __importStar(require("http"));
+const url = __importStar(require("url"));
+const fs = __importStar(require("fs"));
+const log_service_1 = require("../log-service");
+const logLevel_1 = require("../../../models/logLevel");
+class MP3Server {
+    constructor(settings) {
+        this.count = 0;
+        this.mp3Path = '';
+        if (!settings) {
+            return;
+        }
+        this.mp3Path = settings.path;
+        MP3Server.active = true;
+        http
+            .createServer((req, response) => {
+            if (req.url === undefined) {
+                response.writeHead(500);
+                response.end('ungültige Anfrage', 'utf-8');
+                return;
+            }
+            const q = url.parse(req.url, true).query;
+            const fName = q.fname;
+            if (!fName || fName.indexOf('.') >= 0) {
+                response.writeHead(500);
+                response.end('ungültiger Dateiname', 'utf-8');
+                return;
+            }
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.DeepTrace, `Anfrage für ${fName}`);
+            const fPath = this.mp3Path + fName + '.mp3';
+            try {
+                if (!fs.existsSync(fPath)) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Die angefragte Datei existiert nicht ${fName}`);
+                    return;
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+            const filestream = fs.createReadStream(fPath);
+            response.writeHead(200, { 'Content-Type': 'audio/mpeg3' });
+            filestream.pipe(response, { end: true });
+            /*
+          fs.readFile(fPath, (error, data) => {
+              if (error) {
+                if(error.code == 'ENOENT'){
+                    fs.readFile('./404.html', (err, cont) => {
+                        response.writeHead(200, { 'Content-Type': "audio/mpeg3" });
+                        response.end(cont, 'utf-8');
+                    });
+                }
+                else {
+                    response.writeHead(500);
+                    response.end('Sorry, check with the site admin for error: '+error.code+' ..\n');
+                }
+            }
+            else {
+                response.writeHead(200, { 'Content-Type': "audio/mpeg3" });
+                response.end(data, 'utf-8');
+            }
+          })
+          */
+        })
+            .listen(8081);
+    }
+}
+exports.MP3Server = MP3Server;
+MP3Server.active = false;

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

@@ -0,0 +1,12 @@
+import AWS from 'aws-sdk';
+import { iPollySettings } from '../../config/iConfig';
+export declare class PollyService {
+    private static _mp3Path;
+    static active: boolean;
+    static polly: AWS.Polly;
+    static voice: string;
+    static initialize(config: iPollySettings): void;
+    static getDuration(name: 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

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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.PollyService = void 0;
+const aws_sdk_1 = __importDefault(require("aws-sdk"));
+const log_service_1 = require("../log-service");
+const logLevel_1 = require("../../../models/logLevel");
+const fs = __importStar(require("fs"));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const get_mp3_duration_1 = __importDefault(require("get-mp3-duration"));
+const crypto_1 = __importDefault(require("crypto"));
+class PollyService {
+    static initialize(config) {
+        this.active = true;
+        this._mp3Path = config.mp3Path;
+        this.polly = new aws_sdk_1.default.Polly({
+            region: config.region,
+            signatureVersion: config.signatureVersion,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            },
+        });
+        this.voice = config.voiceID;
+    }
+    static getDuration(name) {
+        const fPath = this._mp3Path + name + '.mp3';
+        try {
+            if (fs.existsSync(fPath)) {
+                const duration = (0, get_mp3_duration_1.default)(fs.readFileSync(fPath));
+                return duration;
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+        return 1800000;
+    }
+    static preloadTTS(text) {
+        if (!this.active) {
+            return;
+        }
+        this.tts(text, (link, duration) => {
+            if (duration <= 0) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Retrieving tts for "${text}" failed as duration is 0 or lower`);
+            }
+            else if (!link) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `Retrieving tts for "${text}" failed as link is empty`);
+            }
+        });
+    }
+    static tts(text, cb) {
+        const hash = `${this.voice}_${crypto_1.default.createHash('md5').update(text).digest('hex')}`;
+        const fPath = `${this._mp3Path}${hash}.mp3`;
+        try {
+            if (fs.existsSync(fPath)) {
+                const duration = (0, get_mp3_duration_1.default)(fs.readFileSync(fPath));
+                cb(hash, duration);
+                return;
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+        log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `Für die Nachricht "${text}" fehlt die TTS --> bei AWS anfragen`);
+        const params = {
+            Text: text,
+            OutputFormat: 'mp3',
+            VoiceId: this.voice,
+        };
+        this.polly.synthesizeSpeech(params, (err, data) => {
+            if (err) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `AWS Polly Error: ${err}`);
+                return;
+            }
+            if (!data || data.AudioStream === undefined) {
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `AWS Polly didn't send any data`);
+                return;
+            }
+            log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Debug, `AWS Antwort für (${hash}) erhalten Text: "${text}"`);
+            fs.writeFile(fPath, data.AudioStream, (err) => {
+                const duration = (0, get_mp3_duration_1.default)(data.AudioStream);
+                if (err) {
+                    log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Error, `AWS Polly: Saving failed`);
+                    return;
+                }
+                log_service_1.ServerLogService.writeLog(logLevel_1.LogLevel.Trace, `AWS Polly: Saving sucessfully`);
+                cb(hash, duration);
+                return;
+            });
+        });
+    }
+}
+exports.PollyService = PollyService;
+PollyService.active = false;

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

@@ -0,0 +1,30 @@
+import { SonosDevice } from '@svrooij/sonos/lib';
+export declare class OwnSonosDevice {
+    name: string;
+    roomName: string;
+    device: SonosDevice | undefined;
+    maxPlayOnAllVolume: number;
+    playTestMessage(): void;
+    constructor(name: string, roomName: string, device: SonosDevice | undefined);
+}
+export declare class SonosService {
+    private static sonosManager;
+    private static ownDevices;
+    private static isInitialized;
+    static all: SonosDevice[];
+    static devicesDict: {
+        [name: string]: SonosDevice;
+    };
+    private static checkTimeCallback;
+    private static reinitializationDevice;
+    static addOwnDevices(snDevices: {
+        [name: string]: OwnSonosDevice;
+    }, reinitializationDevice?: OwnSonosDevice): void;
+    static initialize(reinitialize?: boolean): void;
+    static checkAll(): Promise<void>;
+    static speakOnAll(pMessage: string, volumeOverride?: number): void;
+    static playOnDevice(ownSnDevice: OwnSonosDevice, mp3Name: string, duration: number, volume?: number | undefined, onlyWhenPlaying?: boolean | undefined, resolveAfterRevert?: boolean | undefined): void;
+    static speakOnDevice(pMessage: string, ownSnDevice: OwnSonosDevice, volume?: number | undefined, onlyWhenPlaying?: boolean | undefined, resolveAfterRevert?: boolean | undefined): void;
+    static speakTestMessageOnEachDevice(): void;
+    private static initializeDevice;
+}