iobroker.telegram-menu 2.2.4 → 2.3.0

package/build/build/src/app/createState.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createState = void 0;
+const createState = async (_this) => {
+    await _this.setObjectNotExistsAsync('communication.requestIds', {
+        type: 'state',
+        common: {
+            name: 'RequestIds',
+            type: 'string',
+            role: 'state',
+            read: true,
+            write: false,
+            def: '',
+        },
+        native: {},
+    });
+};
+exports.createState = createState;

package/build/build/src/app/dynamicSwitch.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicSwitch = dynamicSwitch;
+const logging_1 = require("./logging");
+const utilities_1 = require("../lib/utilities");
+async function dynamicSwitch(calledValue, device, text) {
+    try {
+        const changedCalledValue = await (0, utilities_1.checkStatusInfo)(calledValue);
+        const splittedArray = changedCalledValue?.replace(/"/g, '').split(':');
+        if (!splittedArray) {
+            return;
+        }
+        device = splittedArray[2];
+        const arrayOfValues = splittedArray[1]
+            .replace('dynSwitch', '')
+            .replace(/\]/g, '')
+            .replace(/\[/g, '')
+            .split(',');
+        const lengthOfRow = parseInt(splittedArray[3]) || 6;
+        const array = [];
+        const keyboard = { inline_keyboard: array };
+        if (arrayOfValues) {
+            let keyboardItemsArray = [];
+            arrayOfValues.forEach((value, index) => {
+                if (value.includes('|')) {
+                    const splittedValue = value.split('|');
+                    keyboardItemsArray.push({
+                        text: splittedValue[0],
+                        callback_data: `menu:dynS:${device}:${splittedValue[1]}`,
+                    });
+                }
+                else {
+                    keyboardItemsArray.push({
+                        text: value,
+                        callback_data: `menu:dynS:${device}:${value}`,
+                    });
+                }
+                if (((index + 1) % lengthOfRow == 0 && index != 0 && arrayOfValues.length > 0) ||
+                    index + 1 == arrayOfValues.length) {
+                    keyboard.inline_keyboard.push(keyboardItemsArray);
+                    keyboardItemsArray = [];
+                }
+            });
+            return { text, keyboard, device };
+        }
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error parsing dynSwitch:', e);
+    }
+}

package/build/build/src/app/dynamicValue.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUserFromDynamicValue = exports.getDynamicValue = exports.setDynamicValue = void 0;
+const utilities_1 = require("../lib/utilities");
+const telegram_1 = require("./telegram");
+const setDynamicValueObj = {};
+const setDynamicValue = async (returnText, ack, id, userToSend, telegramInstance, one_time_keyboard, resize_keyboard, userListWithChatID, parse_mode, confirm) => {
+    const { substring } = (0, utilities_1.decomposeText)(returnText, '{setDynamicValue:', '}');
+    let array = substring.split(':');
+    array = isBraceDeleteEntry(array);
+    const text = array[1];
+    if (text) {
+        await (0, telegram_1.sendToTelegram)({
+            user: userToSend,
+            textToSend: text,
+            keyboard: undefined,
+            instance: telegramInstance,
+            resize_keyboard: resize_keyboard,
+            one_time_keyboard: one_time_keyboard,
+            userListWithChatID: userListWithChatID,
+            parse_mode: parse_mode,
+        });
+    }
+    setDynamicValueObj[userToSend] = {
+        id: id,
+        ack: ack,
+        returnText: text,
+        userToSend: userToSend,
+        parse_mode: parse_mode,
+        confirm: confirm,
+        telegramInstance: telegramInstance,
+        one_time_keyboard: one_time_keyboard,
+        resize_keyboard: resize_keyboard,
+        userListWithChatID: userListWithChatID,
+        valueType: array[2],
+    };
+    if (array[3] && array[3] != '') {
+        return { confirmText: array[3], id: array[4] };
+    }
+    return { confirmText: '', id: undefined };
+};
+exports.setDynamicValue = setDynamicValue;
+const getDynamicValue = (userToSend) => {
+    if (setDynamicValueObj[userToSend]) {
+        return setDynamicValueObj[userToSend];
+    }
+    return null;
+};
+exports.getDynamicValue = getDynamicValue;
+const removeUserFromDynamicValue = (userToSend) => {
+    if (setDynamicValueObj[userToSend]) {
+        delete setDynamicValueObj[userToSend];
+        return true;
+    }
+    return false;
+};
+exports.removeUserFromDynamicValue = removeUserFromDynamicValue;
+function isBraceDeleteEntry(array) {
+    if (array[4] === '}') {
+        return array.slice(0, 4);
+    }
+    return array;
+}

package/build/build/src/app/echarts.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChart = getChart;
+const main_1 = require("../main");
+const logging_1 = require("./logging");
+const telegram_1 = require("./telegram");
+const global_1 = require("./global");
+function getChart(echarts, directoryPicture, user, instanceTelegram, userListWithChatID, resize_keyboard, one_time_keyboard) {
+    try {
+        if (!echarts) {
+            return;
+        }
+        for (const echart of echarts) {
+            const splitPreset = echart.preset.split('.');
+            const instanceOfEchart = `${splitPreset[0]}.${splitPreset[1]}`;
+            if (!(0, global_1.checkDirectoryIsOk)(directoryPicture)) {
+                return;
+            }
+            main_1._this.sendTo(instanceOfEchart, {
+                preset: echart.preset,
+                renderer: 'jpg',
+                background: echart.background,
+                theme: echart.theme,
+                quality: 1.0,
+                fileOnDisk: directoryPicture + echart.filename,
+            }, (result) => {
+                (0, telegram_1.sendToTelegram)({
+                    user: user,
+                    textToSend: result.error || directoryPicture + echart.filename,
+                    instance: instanceTelegram,
+                    resize_keyboard: resize_keyboard,
+                    one_time_keyboard: one_time_keyboard,
+                    userListWithChatID: userListWithChatID,
+                    parse_mode: 'false',
+                }).catch((e) => {
+                    (0, logging_1.errorLogger)('Error send to telegram: ', e);
+                });
+            });
+        }
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error get chart:', e);
+    }
+}

package/build/build/src/app/getstate.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getState = getState;
+const telegram_1 = require("./telegram");
+const action_1 = require("./action");
+const jsonTable_1 = require("./jsonTable");
+const utilities_1 = require("../lib/utilities");
+const global_1 = require("./global");
+const main_1 = require("../main");
+const time_1 = require("../lib/time");
+const string_1 = require("../lib/string");
+function getState(part, userToSend, telegramInstance, one_time_keyboard, resize_keyboard, userListWithChatID) {
+    let text = '';
+    let i = 1;
+    // Parse Mode ist nur immer im ersten Element
+    const parse_mode = part.getData?.[0].parse_mode || 'false';
+    part.getData?.forEach(async (element) => {
+        try {
+            main_1._this.log.debug(`Get Value ID: ${element.id}`);
+            const specifiedSelektor = 'functions=';
+            const id = element.id;
+            let textToSend = '';
+            if (id.indexOf(specifiedSelektor) != -1) {
+                await (0, action_1.idBySelector)(id, element.text, userToSend, element.newline, telegramInstance, one_time_keyboard, resize_keyboard, userListWithChatID);
+                return;
+            }
+            if (element.text.includes('binding:')) {
+                main_1._this.log.debug('Binding');
+                await (0, action_1.bindingFunc)(element.text, userToSend, telegramInstance, one_time_keyboard, resize_keyboard, userListWithChatID, parse_mode);
+                return;
+            }
+            await main_1._this.getForeignStateAsync(id).then(async (value) => {
+                if (!(0, global_1.isDefined)(value)) {
+                    main_1._this.log.error('The state is empty!');
+                    return;
+                }
+                const valueForJson = value.val?.toString() ?? '';
+                main_1._this.log.debug(`State: ${(0, string_1.jsonString)(value)}`);
+                let val = valueForJson.replace(/\\/g, '').replace(/"/g, '');
+                let newline = '';
+                if (element.newline === 'true') {
+                    newline = '\n';
+                }
+                if (element.text) {
+                    textToSend = element.text.toString();
+                    if (element.text.includes('{time.lc') || element.text.includes('{time.ts')) {
+                        textToSend = (await (0, utilities_1.processTimeIdLc)(element.text, id)) || '';
+                        val = '';
+                    }
+                    if (textToSend.includes('{time}')) {
+                        textToSend = (0, time_1.processTimeValue)(textToSend, value);
+                        val = '';
+                    }
+                    if (textToSend.includes('math:')) {
+                        const result = (0, action_1.calcValue)(textToSend, val);
+                        if (result) {
+                            textToSend = result.textToSend;
+                            val = result.val;
+                            main_1._this.log.debug(`TextToSend: ${textToSend} val: ${val}`);
+                        }
+                    }
+                    if (textToSend.includes('round:')) {
+                        const result = (0, action_1.roundValue)(val, textToSend);
+                        if (result) {
+                            main_1._this.log.debug(`The Value was rounded ${JSON.stringify(val)} to ${JSON.stringify(result.val)}`);
+                            val = result.val;
+                            textToSend = result.textToSend;
+                        }
+                    }
+                    if (textToSend.includes('{json')) {
+                        if ((0, global_1.decomposeText)(textToSend, '{json', '}').substring.includes('TextTable')) {
+                            const result = (0, jsonTable_1.createTextTableFromJson)(valueForJson, textToSend);
+                            if (result) {
+                                await (0, telegram_1.sendToTelegram)({
+                                    user: userToSend,
+                                    textToSend: result,
+                                    keyboard: undefined,
+                                    instance: telegramInstance,
+                                    resize_keyboard: one_time_keyboard,
+                                    one_time_keyboard: resize_keyboard,
+                                    userListWithChatID: userListWithChatID,
+                                    parse_mode: parse_mode,
+                                });
+                                return;
+                            }
+                            main_1._this.log.debug('Cannot create a Text-Table');
+                        }
+                        else {
+                            const result = (0, jsonTable_1.createKeyboardFromJson)(valueForJson, textToSend, element.id, userToSend);
+                            if (valueForJson && valueForJson.length > 0) {
+                                if (result && result.text && result.keyboard) {
+                                    (0, telegram_1.sendToTelegramSubmenu)(userToSend, result.text, result.keyboard, telegramInstance, userListWithChatID, parse_mode);
+                                }
+                                return;
+                            }
+                            await (0, telegram_1.sendToTelegram)({
+                                user: userToSend,
+                                textToSend: 'The state is empty!',
+                                keyboard: undefined,
+                                instance: telegramInstance,
+                                resize_keyboard: one_time_keyboard,
+                                one_time_keyboard: resize_keyboard,
+                                userListWithChatID: userListWithChatID,
+                                parse_mode: parse_mode,
+                            });
+                            main_1._this.log.debug('The state is empty!');
+                            return;
+                        }
+                    }
+                    const { val: _val, textToSend: _text, error } = (0, utilities_1.changeValue)(textToSend, val);
+                    val = _val;
+                    textToSend = _text;
+                    if (!error) {
+                        main_1._this.log.debug(`Value Changed to: ${textToSend}`);
+                    }
+                    else {
+                        main_1._this.log.debug(`No Change`);
+                    }
+                    if (textToSend.indexOf('&&') != -1) {
+                        text += `${textToSend.replace('&&', val.toString())}${newline}`;
+                    }
+                    else {
+                        text += `${textToSend} ${val}${newline}`;
+                    }
+                }
+                else {
+                    text += `${val} ${newline}`;
+                }
+                main_1._this.log.debug(`Text: ${text}`);
+                if (i == part.getData?.length) {
+                    if (userToSend) {
+                        await (0, telegram_1.sendToTelegram)({
+                            user: userToSend,
+                            textToSend: text,
+                            keyboard: undefined,
+                            instance: telegramInstance,
+                            resize_keyboard: one_time_keyboard,
+                            one_time_keyboard: resize_keyboard,
+                            userListWithChatID: userListWithChatID,
+                            parse_mode: parse_mode,
+                        });
+                    }
+                }
+                i++;
+            });
+        }
+        catch (error) {
+            error({
+                array: [
+                    { text: 'Error GetData:', val: error.message },
+                    { text: 'Stack:', val: error.stack },
+                ],
+            });
+        }
+    });
+}

package/build/build/src/app/global.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFalsy = exports.isTruthy = exports.isString = exports.deepCopy = exports.deleteDoubleEntriesInArray = exports.isDefined = void 0;
+exports.decomposeText = decomposeText;
+exports.checkDirectoryIsOk = checkDirectoryIsOk;
+exports.parseJSON = parseJSON;
+const logging_1 = require("./logging");
+const main_1 = require("../main");
+const isDefined = (value) => value !== undefined && value !== null;
+exports.isDefined = isDefined;
+const deleteDoubleEntriesInArray = (arr) => arr.filter((item, index) => arr.indexOf(item) === index);
+exports.deleteDoubleEntriesInArray = deleteDoubleEntriesInArray;
+function decomposeText(text, searchValue, secondValue) {
+    const startindex = text.indexOf(searchValue);
+    const endindex = text.indexOf(secondValue, startindex);
+    const substring = text.substring(startindex, endindex + secondValue.length);
+    const textWithoutSubstring = text.replace(substring, '').trim();
+    return {
+        startindex: startindex,
+        endindex: endindex,
+        substring: substring,
+        textWithoutSubstring: textWithoutSubstring,
+    };
+}
+const deepCopy = (obj) => {
+    try {
+        if (!obj) {
+            return undefined;
+        }
+        return JSON.parse(JSON.stringify(obj));
+    }
+    catch (err) {
+        console.error(`Error deepCopy: ${JSON.stringify(err)}`);
+    }
+};
+exports.deepCopy = deepCopy;
+const isString = (value) => typeof value === 'string';
+exports.isString = isString;
+const isTruthy = (value) => ['1', 1, true, 'true'].includes(value);
+exports.isTruthy = isTruthy;
+const isFalsy = (value) => ['0', 0, false, 'false', undefined, null].includes(value);
+exports.isFalsy = isFalsy;
+function checkDirectoryIsOk(directory) {
+    if (['', null, undefined].includes(directory)) {
+        main_1._this.log.error('No directory to save the picture. Please add a directory in the settings with full read and write permissions.');
+        return false;
+    }
+    return true;
+}
+function parseJSON(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        (0, logging_1.errorLogger)('Error parseJson: ', error);
+        return undefined;
+    }
+}

package/build/build/src/app/httpRequest.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequest = httpRequest;
+const axios_1 = __importDefault(require("axios"));
+const telegram_1 = require("./telegram");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const logging_1 = require("./logging");
+const global_1 = require("./global");
+const main_1 = require("../main");
+async function httpRequest(parts, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, directoryPicture) {
+    if (!parts.httpRequest) {
+        return;
+    }
+    for (const part of parts.httpRequest) {
+        const { url, password, user } = part;
+        const method = 'get';
+        main_1._this.log.debug(`URL: ${url}`);
+        try {
+            //prettier-ignore
+            const response = await (0, axios_1.default)(user && password
+                ? {
+                    method: method,
+                    url: url,
+                    responseType: "arraybuffer",
+                    auth: {
+                        username: user,
+                        password: password,
+                    },
+                }
+                : {
+                    method: method,
+                    url: url,
+                    responseType: "arraybuffer",
+                });
+            if (!part.filename) {
+                return;
+            }
+            if (!(0, global_1.checkDirectoryIsOk)(directoryPicture)) {
+                return;
+            }
+            const imagePath = path_1.default.join(directoryPicture, part.filename);
+            fs_1.default.writeFileSync(imagePath, Buffer.from(response.data), 'binary');
+            main_1._this.log.debug(`Pic saved: ${imagePath}`);
+            await (0, telegram_1.sendToTelegram)({
+                user: userToSend,
+                textToSend: imagePath,
+                instance: instanceTelegram,
+                resize_keyboard: resize_keyboard,
+                one_time_keyboard: one_time_keyboard,
+                userListWithChatID: userListWithChatID,
+                parse_mode: 'false',
+            });
+        }
+        catch (e) {
+            (0, logging_1.errorLogger)('Error http request:', e);
+        }
+    }
+    return true;
+}

package/build/build/src/app/jsonTable.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeyboardFromJson = void 0;
+exports.createTextTableFromJson = createTextTableFromJson;
+const global_1 = require("./global");
+const logging_1 = require("./logging");
+const main_1 = require("../main");
+const string_1 = require("../lib/string");
+const lastText = {};
+const createKeyboardFromJson = (val, text, id, user) => {
+    try {
+        if (text) {
+            lastText[user] = text;
+        }
+        else {
+            text = lastText[user];
+        }
+        const array = (0, global_1.decomposeText)(text, '{json:', '}').substring.split(';');
+        const headline = array[2];
+        const itemArray = array[1].replace('[', '').replace(']', '').replace(/"/g, '').split(',');
+        let idShoppingList = false;
+        if (array.length > 3 && array[3] == 'shoppinglist') {
+            idShoppingList = true;
+        }
+        main_1._this.log.debug(`Val: ${val} with type: ${typeof val}`);
+        const valArray = (0, global_1.parseJSON)(val);
+        if (!valArray) {
+            return;
+        }
+        const keyboard = { inline_keyboard: [] };
+        valArray.forEach((element, index) => {
+            const firstRow = [];
+            const rowArray = [];
+            itemArray.forEach(item => {
+                if (index == 0) {
+                    const btnText = item.split(':')[1];
+                    if (btnText.length > 0) {
+                        firstRow.push({ text: btnText, callback_data: '1' });
+                    }
+                }
+                if (idShoppingList) {
+                    const value = element.buttondelete;
+                    const valueDeleteLinkArray = (0, global_1.decomposeText)(value, "('", "')")
+                        .substring.replace("('", '')
+                        .replace(",true')", '')
+                        .split('.');
+                    const instanceAlexa = valueDeleteLinkArray[1];
+                    const valueDeleteId = valueDeleteLinkArray[5];
+                    const instanceShoppingListID = `${id.split('.')[1]}.${id.split('.')[2]}`;
+                    rowArray.push({
+                        text: element[item.split(':')[0]],
+                        callback_data: `sList:${instanceShoppingListID}:${instanceAlexa}:${valueDeleteId}:`,
+                    });
+                }
+                else {
+                    rowArray.push({ text: element[item.split(':')[0]], callback_data: '1' });
+                }
+            });
+            if (index == 0) {
+                keyboard.inline_keyboard.push(firstRow);
+            }
+            keyboard.inline_keyboard.push(rowArray);
+        });
+        main_1._this.log.debug(`Keyboard: ${(0, string_1.jsonString)(keyboard)}`);
+        return { text: headline, keyboard };
+    }
+    catch (err) {
+        (0, logging_1.errorLogger)('Error createKeyboardFromJson:', err);
+    }
+};
+exports.createKeyboardFromJson = createKeyboardFromJson;
+function createTextTableFromJson(val, textToSend) {
+    try {
+        if (!val) {
+            return;
+        }
+        const substring = (0, global_1.decomposeText)(textToSend, '{json:', '}').substring;
+        const array = substring.split(';');
+        const itemArray = array[1].replace('[', '').replace(']', '').replace(/"/g, '').split(',');
+        const valArray = JSON.parse(val);
+        // Array für die Größte Länge der Items
+        const lengthArray = [];
+        // Trägt für jedes Item einen Eintrag im lengthArray ein
+        itemArray.forEach(element => {
+            lengthArray.push(element.split(':')[1].length);
+        });
+        valArray.forEach(element => {
+            itemArray.forEach((item, index) => {
+                if (lengthArray[index] < element[item.split(':')[0]].toString().length) {
+                    lengthArray[index] = element[item.split(':')[0]].toString().length;
+                }
+            });
+        });
+        main_1._this.log.debug(`Length of rows: ${(0, string_1.jsonString)(lengthArray)}`);
+        const headline = array[2];
+        let textTable = textToSend.replace(substring, '').trim();
+        if (textTable != '') {
+            textTable += ' \n\n';
+        }
+        textTable += ` ${headline} \n\``;
+        const enlargeColumn = 1;
+        const reduce = lengthArray.length == 1 ? 2 : 0;
+        const lineLength = lengthArray.reduce((a, b) => a + b, 0) + 5 - reduce + enlargeColumn * lengthArray.length;
+        // Breakline
+        textTable += `${'-'.repeat(lineLength)} \n`;
+        valArray.forEach((element, elementIndex) => {
+            itemArray.forEach((item, index) => {
+                // TableHead
+                if (elementIndex == 0 && index == 0) {
+                    textTable += '|';
+                    itemArray.forEach((item2, i) => {
+                        if (item2.split(':')[1].length > 0) {
+                            textTable += ` ${item2
+                                .split(':')[1]
+                                .toString()
+                                .padEnd(lengthArray[i] + enlargeColumn, ' ')}|`;
+                            if (i == itemArray.length - 1) {
+                                textTable += '\n';
+                                // Breakline
+                                textTable += `${'-'.repeat(lineLength)} \n`;
+                            }
+                        }
+                        else {
+                            textTable = textTable.slice(0, -1);
+                        }
+                    });
+                }
+                // TableBody
+                if (index == 0) {
+                    textTable += '|';
+                }
+                textTable += ` ${element[item.split(':')[0]].toString().padEnd(lengthArray[index] + enlargeColumn, ' ')}|`;
+                if (index == itemArray.length - 1) {
+                    textTable += '\n';
+                }
+            });
+        });
+        // Breakline
+        textTable += '-'.repeat(lineLength);
+        textTable += '`';
+        return textTable;
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error createTextTableFromJson:', e);
+    }
+}

package/build/build/src/app/logging.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorLogger = void 0;
+const main_1 = require("../main");
+const errorLogger = (title, e) => {
+    main_1._this.log.error(title);
+    main_1._this.log.error(`Error message: ${e.message}`);
+    main_1._this.log.error(`Error stack: ${e.stack}`);
+    main_1._this.log.error(`Server response: ${e?.response?.status}`);
+    main_1._this.log.error(`Server data: ${e?.response?.data}`);
+};
+exports.errorLogger = errorLogger;