iobroker.telegram-menu 2.2.4 → 2.3.1

package/build/build/src/app/subMenu.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subMenu = subMenu;
+exports.callSubMenu = callSubMenu;
+const backMenu_1 = require("./backMenu");
+const setstate_1 = require("./setstate");
+const telegram_1 = require("./telegram");
+const utilities_1 = require("../lib/utilities");
+const subscribeStates_1 = require("./subscribeStates");
+const messageIds_1 = require("./messageIds");
+const dynamicSwitch_1 = require("./dynamicSwitch");
+const global_1 = require("./global");
+const main_1 = require("../main");
+const string_1 = require("../lib/string");
+const logging_1 = require("./logging");
+let step = 0;
+let returnIDToListenTo = [];
+let splittedData = [];
+const getMenuValues = (obj) => {
+    const splitText = obj[0].split(':');
+    return { callbackData: splitText[1], device: splitText[2], val: splitText[3] };
+};
+const deleteMessages = async (obj) => {
+    const navToGoBack = obj.device2Switch;
+    if (obj.callbackData.includes('deleteAll')) {
+        await (0, messageIds_1.deleteMessageIds)(obj.userToSend, obj.userListWithChatID, obj.instanceTelegram, 'all');
+    }
+    if (navToGoBack && navToGoBack != '') {
+        return { navToGoBack: navToGoBack };
+    }
+    return;
+};
+const setDynamicValue = async (obj) => {
+    main_1._this.log.debug(`State: ${obj.val}`);
+    const result = await (0, setstate_1.setState)(obj.part, obj.userToSend, obj.val, true, obj.instanceTelegram, obj.resize_keyboard, obj.one_time_keyboard, obj.userListWithChatID);
+    if (Array.isArray(result)) {
+        returnIDToListenTo = result;
+    }
+    return {
+        returnIds: returnIDToListenTo,
+    };
+};
+const createSubmenuPercent = (obj) => {
+    const { callbackData, device2Switch } = obj;
+    step = parseFloat(callbackData.replace('percent', ''));
+    let rowEntries = 0;
+    let menu = [];
+    const keyboard = {
+        inline_keyboard: [],
+    };
+    for (let i = 100; i >= 0; i -= step) {
+        menu.push({
+            text: `${i}%`,
+            callback_data: `submenu:percent${step},${i}:${device2Switch}`,
+        });
+        if (i != 0 && i - step < 0) {
+            menu.push({
+                text: `0%`,
+                callback_data: `submenu:percent${step},${0}:${device2Switch}`,
+            });
+        }
+        rowEntries++;
+        if (rowEntries == 8) {
+            keyboard.inline_keyboard.push(menu);
+            menu = [];
+            rowEntries = 0;
+        }
+    }
+    if (rowEntries != 0) {
+        keyboard.inline_keyboard.push(menu);
+    }
+    return { text: obj.text, keyboard: keyboard, device: device2Switch };
+};
+const setFirstMenuValue = async (obj) => {
+    let val;
+    main_1._this.log.debug(`SplitData: ${(0, string_1.jsonString)(splittedData)}`);
+    if (splittedData[1].split('.')[1] == 'false') {
+        val = false;
+    }
+    else if (splittedData[1].split('.')[1] == 'true') {
+        val = true;
+    }
+    else {
+        val = splittedData[1].split('.')[1];
+    }
+    const result = await (0, setstate_1.setState)(obj.part, obj.userToSend, val, true, obj.instanceTelegram, obj.resize_keyboard, obj.one_time_keyboard, obj.userListWithChatID);
+    if (Array.isArray(result)) {
+        returnIDToListenTo = result;
+    }
+    return { returnIds: returnIDToListenTo };
+};
+const setSecondMenuValue = async (obj) => {
+    let val;
+    if (splittedData[2].split('.')[1] == 'false') {
+        val = false;
+    }
+    else if (splittedData[2].split('.')[1] == 'true') {
+        val = true;
+    }
+    else {
+        val = splittedData[2].split('.')[1];
+    }
+    const result = await (0, setstate_1.setState)(obj.part, obj.userToSend, val, true, obj.instanceTelegram, obj.one_time_keyboard, obj.resize_keyboard, obj.userListWithChatID);
+    if (Array.isArray(result)) {
+        returnIDToListenTo = result;
+    }
+    return { returnIds: returnIDToListenTo };
+};
+const createSubmenuNumber = (obj) => {
+    let callbackData = obj.callbackData;
+    const device2Switch = obj.device2Switch;
+    if (callbackData.includes('(-)')) {
+        callbackData = callbackData.replace('(-)', 'negativ');
+    }
+    const splittedData = callbackData.replace('number', '').split('-');
+    let rowEntries = 0;
+    let menu = [];
+    const keyboard = {
+        inline_keyboard: [],
+    };
+    let unit = '';
+    if (splittedData[3] != '') {
+        unit = splittedData[3];
+    }
+    let start, end;
+    const firstValueInText = parseFloat(splittedData[0].includes('negativ') ? splittedData[0].replace('negativ', '-') : splittedData[0]);
+    const secondValueInText = parseFloat(splittedData[1].includes('negativ') ? splittedData[1].replace('negativ', '-') : splittedData[1]);
+    if (firstValueInText < secondValueInText) {
+        start = secondValueInText;
+        end = firstValueInText;
+    }
+    else {
+        start = firstValueInText;
+        end = secondValueInText;
+    }
+    let index = -1;
+    let maxEntriesPerRow = 8;
+    const step = parseFloat(splittedData[2].includes('negativ') ? splittedData[2].replace('negativ', '-') : splittedData[2]);
+    if (step < 1) {
+        maxEntriesPerRow = 6;
+    }
+    for (let i = start; i >= end; i -= step) {
+        // Zahlen umdrehen
+        if (parseFloat(splittedData[0]) < parseFloat(splittedData[1])) {
+            if (i === start) {
+                index = end - step;
+            }
+            index = index + step;
+        }
+        else {
+            index = i;
+        }
+        menu.push({
+            text: `${index}${unit}`,
+            callback_data: `submenu:${callbackData}:${device2Switch}:${index}`,
+        });
+        rowEntries++;
+        if (rowEntries == maxEntriesPerRow) {
+            keyboard.inline_keyboard.push(menu);
+            menu = [];
+            rowEntries = 0;
+        }
+    }
+    if (rowEntries != 0) {
+        keyboard.inline_keyboard.push(menu);
+    }
+    main_1._this.log.debug(`Keyboard: ${(0, string_1.jsonString)(keyboard)}`);
+    return { text: obj.text, keyboard, device: device2Switch };
+};
+const createSwitchMenu = ({ device2Switch, callbackData, text, }) => {
+    splittedData = callbackData.split('-');
+    const keyboard = {
+        inline_keyboard: [
+            [
+                {
+                    text: splittedData[1].split('.')[0],
+                    callback_data: `menu:first:${device2Switch}`,
+                },
+                {
+                    text: splittedData[2].split('.')[0],
+                    callback_data: `menu:second:${device2Switch}`,
+                },
+            ],
+        ],
+    };
+    return { text: text, keyboard, device: device2Switch };
+};
+const setValueForSubmenuPercent = async (obj) => {
+    const value = parseInt(obj.calledValue.split(':')[1].split(',')[1]);
+    const result = await (0, setstate_1.setState)(obj.part, obj.userToSend, value, true, obj.instanceTelegram, obj.resize_keyboard, obj.one_time_keyboard, obj.userListWithChatID);
+    if (Array.isArray(result)) {
+        returnIDToListenTo = result;
+    }
+    return { returnIds: returnIDToListenTo };
+};
+const setValueForSubmenuNumber = async (obj) => {
+    main_1._this.log.debug(`CallbackData: ${obj.callbackData}`);
+    const value = parseFloat(obj.calledValue.split(':')[3]);
+    const device2Switch = obj.calledValue.split(':')[2];
+    const result = await (0, setstate_1.setState)(obj.part, obj.userToSend, value, true, obj.instanceTelegram, obj.resize_keyboard, obj.one_time_keyboard, obj.userListWithChatID);
+    if (Array.isArray(result)) {
+        returnIDToListenTo = result;
+    }
+    return { returnIds: returnIDToListenTo, device2Switch };
+};
+const back = async (obj) => {
+    const result = await (0, backMenu_1.switchBack)(obj.userToSend, obj.allMenusWithData, obj.menus);
+    if (result) {
+        await (0, telegram_1.sendToTelegram)({
+            user: obj.userToSend,
+            textToSend: result.texttosend,
+            keyboard: result.menuToSend,
+            instance: obj.instanceTelegram,
+            resize_keyboard: obj.resize_keyboard,
+            one_time_keyboard: obj.one_time_keyboard,
+            userListWithChatID: obj.userListWithChatID,
+            parse_mode: result.parseMode,
+        });
+    }
+};
+async function callSubMenu(jsonStringNav, newObjectNavStructure, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, part, allMenusWithData, menus, setStateIdsToListenTo, navObj) {
+    try {
+        const obj = await subMenu({
+            jsonStringNav: jsonStringNav,
+            userToSend: userToSend,
+            instanceTelegram: instanceTelegram,
+            resize_keyboard: resize_keyboard,
+            one_time_keyboard: one_time_keyboard,
+            userListWithChatID: userListWithChatID,
+            part,
+            allMenusWithData: allMenusWithData,
+            menus,
+            navObj,
+        });
+        main_1._this.log.debug(`Submenu: ${(0, string_1.jsonString)(obj)}`);
+        if (obj?.returnIds) {
+            setStateIdsToListenTo = obj.returnIds;
+            await (0, subscribeStates_1._subscribeAndUnSubscribeForeignStatesAsync)({ array: obj.returnIds });
+        }
+        if (obj?.text && obj?.keyboard) {
+            (0, telegram_1.sendToTelegramSubmenu)(userToSend, obj.text, obj.keyboard, instanceTelegram, userListWithChatID, part.parse_mode || 'false');
+        }
+        return { setStateIdsToListenTo: setStateIdsToListenTo, newNav: obj?.navToGoBack };
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error callSubMenu:', e);
+    }
+}
+async function subMenu({ jsonStringNav, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, part, allMenusWithData, menus, navObj, }) {
+    try {
+        main_1._this.log.debug(`Menu : ${navObj[0][0]}`);
+        let text = '';
+        if (part?.text && part.text != '') {
+            text = await (0, utilities_1.checkStatusInfo)(part.text);
+        }
+        const called = (0, global_1.parseJSON)(jsonStringNav);
+        if (!called?.length) {
+            return;
+        }
+        const { callbackData, device: device2Switch, val } = getMenuValues(called[0]);
+        if (callbackData.includes('delete')) {
+            return await deleteMessages({
+                userToSend,
+                userListWithChatID,
+                instanceTelegram,
+                device2Switch,
+                callbackData,
+            });
+        }
+        else if (callbackData.includes('switch')) {
+            return createSwitchMenu({ callbackData, text, device2Switch });
+        }
+        else if (callbackData.includes('first')) {
+            return await setFirstMenuValue({
+                part,
+                userToSend,
+                instanceTelegram,
+                resize_keyboard,
+                one_time_keyboard,
+                userListWithChatID,
+            });
+        }
+        else if (callbackData.includes('second')) {
+            return await setSecondMenuValue({
+                part,
+                userToSend,
+                instanceTelegram,
+                resize_keyboard,
+                one_time_keyboard,
+                userListWithChatID,
+            });
+        }
+        else if (callbackData.includes('dynSwitch')) {
+            return (0, dynamicSwitch_1.dynamicSwitch)(jsonStringNav, device2Switch, text);
+        }
+        else if (callbackData.includes('dynS')) {
+            return await setDynamicValue({
+                val,
+                userToSend,
+                instanceTelegram,
+                resize_keyboard,
+                one_time_keyboard,
+                userListWithChatID,
+                part,
+            });
+        }
+        else if (!jsonStringNav.includes('submenu') && callbackData.includes('percent')) {
+            return createSubmenuPercent({ callbackData, text, device2Switch });
+        }
+        else if (jsonStringNav.includes(`submenu:percent${step}`)) {
+            return await setValueForSubmenuPercent({
+                callbackData,
+                calledValue: jsonStringNav,
+                userToSend,
+                instanceTelegram,
+                resize_keyboard,
+                one_time_keyboard,
+                userListWithChatID,
+                part,
+                allMenusWithData,
+                menus,
+            });
+        }
+        else if (!jsonStringNav.includes('submenu') && callbackData.includes('number')) {
+            return createSubmenuNumber({ callbackData, text, device2Switch });
+        }
+        else if (jsonStringNav.includes(`submenu:${callbackData}`)) {
+            const result = await setValueForSubmenuNumber({
+                callbackData,
+                calledValue: jsonStringNav,
+                userToSend,
+                instanceTelegram,
+                resize_keyboard,
+                one_time_keyboard,
+                userListWithChatID,
+                part,
+            });
+            // device2Switch = result.device2Switch;
+            return result.returnIds ? { returnIds: result.returnIds } : undefined;
+        }
+        else if (callbackData === 'back') {
+            await back({
+                userToSend,
+                allMenusWithData,
+                menus,
+                instanceTelegram,
+                resize_keyboard,
+                one_time_keyboard,
+                userListWithChatID,
+            });
+        }
+        return;
+    }
+    catch (error) {
+        error([
+            { text: 'Error subMenu:', val: error.message },
+            { text: 'Stack', val: error.stack },
+        ]);
+    }
+}

package/build/build/src/app/subscribeStates.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._subscribeAndUnSubscribeForeignStatesAsync = _subscribeAndUnSubscribeForeignStatesAsync;
+exports._subscribeForeignStatesAsync = _subscribeForeignStatesAsync;
+const main_1 = require("../main");
+const global_1 = require("./global");
+const string_1 = require("../lib/string");
+async function _subscribeAndUnSubscribeForeignStatesAsync(obj) {
+    if (obj.id) {
+        main_1._this.log.debug(`Subscribe to ${obj.id}`);
+    }
+    else if (obj.array) {
+        for (const element of obj.array) {
+            await main_1._this.subscribeForeignStatesAsync(element.id);
+        }
+    }
+}
+async function _subscribeForeignStatesAsync(array) {
+    array = (0, global_1.deleteDoubleEntriesInArray)(array);
+    for (const element of array) {
+        await main_1._this.subscribeForeignStatesAsync(element);
+    }
+    main_1._this.log.debug(`Subscribe all States of: ${(0, string_1.jsonString)(array)}`);
+}

package/build/build/src/app/telegram.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendLocationToTelegram = void 0;
+exports.sendToTelegram = sendToTelegram;
+exports.sendToTelegramSubmenu = sendToTelegramSubmenu;
+const logging_1 = require("./logging");
+const utilities_1 = require("../lib/utilities");
+const main_1 = require("../main");
+const global_1 = require("./global");
+const utils_1 = require("../lib/utils");
+const string_1 = require("../lib/string");
+async function sendToTelegram({ user = '', textToSend, keyboard, instance = 'telegram.0', resize_keyboard = true, one_time_keyboard = true, userListWithChatID, parse_mode, }) {
+    try {
+        const chatId = (0, utils_1.getChatID)(userListWithChatID, user);
+        const parse_modeType = getParseMode(parse_mode);
+        main_1._this.log.debug(`Send to: ${user} => ${textToSend}`);
+        main_1._this.log.debug(`Instance: ${instance}`);
+        main_1._this.log.debug(`UserListWithChatID	: ${(0, string_1.jsonString)(userListWithChatID)}`);
+        main_1._this.log.debug(`Parse_mode	: ${parse_mode}`);
+        main_1._this.log.debug(`ChatId	: ${chatId}`);
+        main_1._this.log.debug(`ParseModeType: ${parse_modeType}`);
+        textToSend = (0, string_1.validateNewLine)(textToSend);
+        if (!keyboard) {
+            main_1._this.log.debug('No Keyboard');
+            main_1._this.sendTo(instance, 'send', {
+                text: textToSend,
+                chatId: chatId,
+                parse_mode: parse_modeType,
+            }, function (res) {
+                main_1._this.log.debug(`Sent Value to ${(0, string_1.jsonString)(res)} users!`);
+            });
+        }
+        else {
+            const text = await (0, utilities_1.checkStatusInfo)(textToSend);
+            main_1._this.sendTo(instance, 'send', {
+                chatId: chatId,
+                parse_mode: parse_modeType,
+                text: text,
+                reply_markup: {
+                    keyboard: keyboard,
+                    resize_keyboard: resize_keyboard,
+                    one_time_keyboard: one_time_keyboard,
+                },
+            }, function (res) {
+                main_1._this.log.debug(`Sent Value to ${(0, string_1.jsonString)(res)} users!`);
+            });
+        }
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error sendToTelegram:', e);
+    }
+}
+function sendToTelegramSubmenu(user, textToSend, keyboard, instance = 'telegram.0', userListWithChatID, parse_mode) {
+    const parseModeType = getParseMode(parse_mode);
+    main_1._this.log.debug(`Send this ParseMode: ${parseModeType}`);
+    try {
+        const chatId = (0, utils_1.getChatID)(userListWithChatID, user);
+        textToSend = (0, string_1.validateNewLine)(textToSend);
+        main_1._this.sendTo(instance, 'send', {
+            chatId: chatId,
+            parse_mode: parseModeType,
+            text: textToSend,
+            reply_markup: keyboard,
+        });
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error sendToTelegramSubmenu:', e);
+    }
+}
+const sendLocationToTelegram = async (user, data, instance, userListWithChatID) => {
+    try {
+        const chatId = (0, utils_1.getChatID)(userListWithChatID, user);
+        for (const element of data) {
+            if (!(element.latitude || element.longitude)) {
+                continue;
+            }
+            const latitude = await main_1._this.getForeignStateAsync(element.latitude);
+            const longitude = await main_1._this.getForeignStateAsync(element.longitude);
+            if (!latitude || !longitude) {
+                continue;
+            }
+            main_1._this.sendTo(instance, {
+                chatId: chatId,
+                latitude: latitude.val,
+                longitude: longitude.val,
+                disable_notification: true,
+            });
+        }
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error sendLocationToTelegram:', e);
+    }
+};
+exports.sendLocationToTelegram = sendLocationToTelegram;
+function getParseMode(val) {
+    if ((0, global_1.isTruthy)(val)) {
+        return 'HTML';
+    }
+    return 'Markdown';
+}

package/build/build/src/lib/string.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceAll = exports.validateNewLine = exports.jsonString = void 0;
+exports.parseJSON = parseJSON;
+const main_1 = require("../main");
+const jsonString = (val) => JSON.stringify(val);
+exports.jsonString = jsonString;
+function parseJSON(val) {
+    try {
+        const parsed = JSON.parse(val);
+        return { json: parsed, isValidJson: true };
+    }
+    catch (error) {
+        main_1._this.log.error(`Error parse json: ${(0, exports.jsonString)(error)}`);
+        return { json: {}, isValidJson: false };
+    }
+}
+const validateNewLine = (text) => {
+    const { json, isValidJson } = parseJSON(text);
+    if (isValidJson) {
+        text = json;
+    }
+    return text.replace(/""/g, '"').replace(/\\n/g, '\n');
+};
+exports.validateNewLine = validateNewLine;
+const replaceAll = (text, searchValue, replaceValue) => text.replace(new RegExp(searchValue, 'g'), replaceValue);
+exports.replaceAll = replaceAll;

package/build/build/src/lib/time.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTimeValue = exports.toLocaleDate = void 0;
+const main_1 = require("../main");
+const toLocaleDate = (time) => {
+    return time.toLocaleDateString('de-DE', {
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    });
+};
+exports.toLocaleDate = toLocaleDate;
+const processTimeValue = (textToSend, obj) => {
+    const date = new Date(Number(obj.val));
+    if (isNaN(date.getTime())) {
+        main_1._this.log.error(`Invalid Date: ${String(date)}`);
+        return textToSend;
+    }
+    return textToSend.replace('{time}', (0, exports.toLocaleDate)(date));
+};
+exports.processTimeValue = processTimeValue;