iobroker.telegram-menu 2.2.4 → 2.3.1

package/build/app/telegram.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/app/telegram.ts"],
+  "sourcesContent": ["import { errorLogger } from './logging';\nimport { returnTextModifier } from '../lib/utilities';\nimport { adapter } from '../main';\nimport type { Keyboard, Location, Telegram, TelegramParams } from '../types/types';\nimport { getChatID } from '../lib/utils';\nimport { cleanUpString, isEmptyString, jsonString } from '../lib/string';\nimport { getParseMode } from '../lib/appUtils';\n\nfunction validateTextToSend(textToSend: string | undefined): void {\n    if (!textToSend || isEmptyString(textToSend)) {\n        adapter.log.error('There is a problem! Text to send is empty or undefined, please check your configuration.');\n    }\n}\n\nasync function sendToTelegram({\n    userToSend,\n    textToSend,\n    keyboard,\n    telegramParams,\n    parse_mode,\n}: Telegram): Promise<void> {\n    try {\n        const { telegramInstance, resize_keyboard, one_time_keyboard, userListWithChatID } = telegramParams;\n        const chatId = getChatID(userListWithChatID, userToSend);\n\n        adapter.log.debug(\n            `Send to: { user: ${userToSend} , chatId :${chatId} , text: ${textToSend} , instance: ${telegramInstance} , userListWithChatID: ${jsonString(userListWithChatID)} , parseMode: ${parse_mode} }`,\n        );\n        validateTextToSend(textToSend);\n\n        const validatedTextToSend = cleanUpString(textToSend);\n        if (!keyboard) {\n            adapter.sendTo(\n                telegramInstance,\n                'send',\n                {\n                    text: validatedTextToSend,\n                    chatId,\n                    parse_mode: getParseMode(parse_mode),\n                },\n                res => telegramLogger(res),\n            );\n            return;\n        }\n\n        adapter.sendTo(\n            telegramInstance,\n            'send',\n            {\n                chatId,\n                parse_mode: getParseMode(parse_mode),\n                text: await returnTextModifier(validatedTextToSend),\n                reply_markup: {\n                    keyboard,\n                    resize_keyboard,\n                    one_time_keyboard,\n                },\n            },\n            res => telegramLogger(res),\n        );\n    } catch (e) {\n        errorLogger('Error sendToTelegram:', e, adapter);\n    }\n}\n\nfunction sendToTelegramSubmenu(\n    user: string,\n    textToSend: string,\n    keyboard: Keyboard,\n    telegramParams: TelegramParams,\n    parse_mode?: boolean,\n): void {\n    const { telegramInstance: instance, userListWithChatID } = telegramParams;\n    validateTextToSend(textToSend);\n    adapter.sendTo(\n        instance,\n        'send',\n        {\n            chatId: getChatID(userListWithChatID, user),\n            parse_mode: getParseMode(parse_mode),\n            text: cleanUpString(textToSend),\n            reply_markup: keyboard,\n        },\n        (res: any) => telegramLogger(res),\n    );\n}\n\nconst sendLocationToTelegram = async (\n    user: string,\n    data: Location[],\n    telegramParams: TelegramParams,\n): Promise<void> => {\n    const { userListWithChatID, telegramInstance: instance } = telegramParams;\n    try {\n        const chatId = getChatID(userListWithChatID, user);\n\n        for (const { longitude: longitudeID, latitude: latitudeID } of data) {\n            if (!(latitudeID || longitudeID)) {\n                continue;\n            }\n\n            const latitude = await adapter.getForeignStateAsync(latitudeID);\n            const longitude = await adapter.getForeignStateAsync(longitudeID);\n            if (!latitude || !longitude) {\n                continue;\n            }\n            adapter.sendTo(\n                instance,\n                {\n                    chatId: chatId,\n                    latitude: latitude.val,\n                    longitude: longitude.val,\n                    disable_notification: true,\n                },\n                (res: any) => telegramLogger(res),\n            );\n        }\n    } catch (e: any) {\n        errorLogger('Error send location to telegram:', e, adapter);\n    }\n};\n\nfunction telegramLogger(res: any): void {\n    adapter.log.debug(`Telegram response : \"${jsonString(res)}\"`);\n}\n\nexport { sendToTelegram, sendToTelegramSubmenu, sendLocationToTelegram };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA4B;AAC5B,uBAAmC;AACnC,kBAAwB;AAExB,mBAA0B;AAC1B,oBAAyD;AACzD,sBAA6B;AAE7B,SAAS,mBAAmB,YAAsC;AAC9D,MAAI,CAAC,kBAAc,6BAAc,UAAU,GAAG;AAC1C,wBAAQ,IAAI,MAAM,0FAA0F;AAAA,EAChH;AACJ;AAEA,eAAe,eAAe;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,GAA4B;AACxB,MAAI;AACA,UAAM,EAAE,kBAAkB,iBAAiB,mBAAmB,mBAAmB,IAAI;AACrF,UAAM,aAAS,wBAAU,oBAAoB,UAAU;AAEvD,wBAAQ,IAAI;AAAA,MACR,oBAAoB,UAAU,cAAc,MAAM,YAAY,UAAU,gBAAgB,gBAAgB,8BAA0B,0BAAW,kBAAkB,CAAC,iBAAiB,UAAU;AAAA,IAC/L;AACA,uBAAmB,UAAU;AAE7B,UAAM,0BAAsB,6BAAc,UAAU;AACpD,QAAI,CAAC,UAAU;AACX,0BAAQ;AAAA,QACJ;AAAA,QACA;AAAA,QACA;AAAA,UACI,MAAM;AAAA,UACN;AAAA,UACA,gBAAY,8BAAa,UAAU;AAAA,QACvC;AAAA,QACA,SAAO,eAAe,GAAG;AAAA,MAC7B;AACA;AAAA,IACJ;AAEA,wBAAQ;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,QACI;AAAA,QACA,gBAAY,8BAAa,UAAU;AAAA,QACnC,MAAM,UAAM,qCAAmB,mBAAmB;AAAA,QAClD,cAAc;AAAA,UACV;AAAA,UACA;AAAA,UACA;AAAA,QACJ;AAAA,MACJ;AAAA,MACA,SAAO,eAAe,GAAG;AAAA,IAC7B;AAAA,EACJ,SAAS,GAAG;AACR,oCAAY,yBAAyB,GAAG,mBAAO;AAAA,EACnD;AACJ;AAEA,SAAS,sBACL,MACA,YACA,UACA,gBACA,YACI;AACJ,QAAM,EAAE,kBAAkB,UAAU,mBAAmB,IAAI;AAC3D,qBAAmB,UAAU;AAC7B,sBAAQ;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,MACI,YAAQ,wBAAU,oBAAoB,IAAI;AAAA,MAC1C,gBAAY,8BAAa,UAAU;AAAA,MACnC,UAAM,6BAAc,UAAU;AAAA,MAC9B,cAAc;AAAA,IAClB;AAAA,IACA,CAAC,QAAa,eAAe,GAAG;AAAA,EACpC;AACJ;AAEA,MAAM,yBAAyB,OAC3B,MACA,MACA,mBACgB;AAChB,QAAM,EAAE,oBAAoB,kBAAkB,SAAS,IAAI;AAC3D,MAAI;AACA,UAAM,aAAS,wBAAU,oBAAoB,IAAI;AAEjD,eAAW,EAAE,WAAW,aAAa,UAAU,WAAW,KAAK,MAAM;AACjE,UAAI,EAAE,cAAc,cAAc;AAC9B;AAAA,MACJ;AAEA,YAAM,WAAW,MAAM,oBAAQ,qBAAqB,UAAU;AAC9D,YAAM,YAAY,MAAM,oBAAQ,qBAAqB,WAAW;AAChE,UAAI,CAAC,YAAY,CAAC,WAAW;AACzB;AAAA,MACJ;AACA,0BAAQ;AAAA,QACJ;AAAA,QACA;AAAA,UACI;AAAA,UACA,UAAU,SAAS;AAAA,UACnB,WAAW,UAAU;AAAA,UACrB,sBAAsB;AAAA,QAC1B;AAAA,QACA,CAAC,QAAa,eAAe,GAAG;AAAA,MACpC;AAAA,IACJ;AAAA,EACJ,SAAS,GAAQ;AACb,oCAAY,oCAAoC,GAAG,mBAAO;AAAA,EAC9D;AACJ;AAEA,SAAS,eAAe,KAAgB;AACpC,sBAAQ,IAAI,MAAM,4BAAwB,0BAAW,GAAG,CAAC,GAAG;AAChE;",
+  "names": []
+}

package/build/app/validateMenus.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validateMenus_exports = {};
+__export(validateMenus_exports, {
+  isCreateDynamicSwitch: () => isCreateDynamicSwitch,
+  isCreateSubmenuNumber: () => isCreateSubmenuNumber,
+  isCreateSubmenuPercent: () => isCreateSubmenuPercent,
+  isCreateSwitch: () => isCreateSwitch,
+  isDeleteMenu: () => isDeleteMenu,
+  isFirstMenuValue: () => isFirstMenuValue,
+  isMenuBack: () => isMenuBack,
+  isSecondMenuValue: () => isSecondMenuValue,
+  isSetDynamicSwitchVal: () => isSetDynamicSwitchVal,
+  isSetSubmenuNumber: () => isSetSubmenuNumber,
+  isSetSubmenuPercent: () => isSetSubmenuPercent,
+  isSubmenuOrMenu: () => isSubmenuOrMenu
+});
+module.exports = __toCommonJS(validateMenus_exports);
+const isMenuBack = (str) => str.includes("menu:back");
+const isDeleteMenu = (str) => str.includes("delete");
+const isCreateSwitch = (str) => str.includes("switch");
+const isFirstMenuValue = (str) => str.includes("first");
+const isSecondMenuValue = (str) => str.includes("second");
+const isCreateDynamicSwitch = (str) => str.includes("dynSwitch");
+const isSetDynamicSwitchVal = (str) => str.includes("dynS");
+const isSubmenuOrMenu = (val) => val.startsWith("menu") || val.startsWith("submenu");
+const isCreateSubmenuPercent = (menuString, cbData) => !menuString.includes("submenu") && cbData.includes("percent");
+const isSetSubmenuPercent = (menuString, step) => menuString.includes(`submenu:percent${step}`);
+const isSetSubmenuNumber = (menuString, cbData) => menuString.includes(`submenu:${cbData}`);
+function isCreateSubmenuNumber(menuString, callbackData) {
+  return !menuString.includes("submenu") && callbackData.includes("number");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCreateDynamicSwitch,
+  isCreateSubmenuNumber,
+  isCreateSubmenuPercent,
+  isCreateSwitch,
+  isDeleteMenu,
+  isFirstMenuValue,
+  isMenuBack,
+  isSecondMenuValue,
+  isSetDynamicSwitchVal,
+  isSetSubmenuNumber,
+  isSetSubmenuPercent,
+  isSubmenuOrMenu
+});
+//# sourceMappingURL=validateMenus.js.map

package/build/app/validateMenus.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/app/validateMenus.ts"],
+  "sourcesContent": ["export const isMenuBack = (str: string): boolean => str.includes('menu:back');\nexport const isDeleteMenu = (str: string): boolean => str.includes('delete');\nexport const isCreateSwitch = (str: string): boolean => str.includes('switch');\nexport const isFirstMenuValue = (str: string): boolean => str.includes('first');\nexport const isSecondMenuValue = (str: string): boolean => str.includes('second');\nexport const isCreateDynamicSwitch = (str: string): boolean => str.includes('dynSwitch');\nexport const isSetDynamicSwitchVal = (str: string): boolean => str.includes('dynS');\nexport const isSubmenuOrMenu = (val: string): boolean => val.startsWith('menu') || val.startsWith('submenu');\nexport const isCreateSubmenuPercent = (menuString: string, cbData: string): boolean =>\n    !menuString.includes('submenu') && cbData.includes('percent');\n\nexport const isSetSubmenuPercent = (menuString: string, step: number): boolean =>\n    menuString.includes(`submenu:percent${step}`);\n\nexport const isSetSubmenuNumber = (menuString: string, cbData: string): boolean =>\n    menuString.includes(`submenu:${cbData}`);\n\nexport function isCreateSubmenuNumber(menuString: string, callbackData: string): boolean {\n    return !menuString.includes('submenu') && callbackData.includes('number');\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,aAAa,CAAC,QAAyB,IAAI,SAAS,WAAW;AACrE,MAAM,eAAe,CAAC,QAAyB,IAAI,SAAS,QAAQ;AACpE,MAAM,iBAAiB,CAAC,QAAyB,IAAI,SAAS,QAAQ;AACtE,MAAM,mBAAmB,CAAC,QAAyB,IAAI,SAAS,OAAO;AACvE,MAAM,oBAAoB,CAAC,QAAyB,IAAI,SAAS,QAAQ;AACzE,MAAM,wBAAwB,CAAC,QAAyB,IAAI,SAAS,WAAW;AAChF,MAAM,wBAAwB,CAAC,QAAyB,IAAI,SAAS,MAAM;AAC3E,MAAM,kBAAkB,CAAC,QAAyB,IAAI,WAAW,MAAM,KAAK,IAAI,WAAW,SAAS;AACpG,MAAM,yBAAyB,CAAC,YAAoB,WACvD,CAAC,WAAW,SAAS,SAAS,KAAK,OAAO,SAAS,SAAS;AAEzD,MAAM,sBAAsB,CAAC,YAAoB,SACpD,WAAW,SAAS,kBAAkB,IAAI,EAAE;AAEzC,MAAM,qBAAqB,CAAC,YAAoB,WACnD,WAAW,SAAS,WAAW,MAAM,EAAE;AAEpC,SAAS,sBAAsB,YAAoB,cAA+B;AACrF,SAAO,CAAC,WAAW,SAAS,SAAS,KAAK,aAAa,SAAS,QAAQ;AAC5E;",
+  "names": []
+}

package/build/build/src/app/action.js

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMenusWithUserToSend = exports.getUserToSendFromUserListWithChatID = exports.checkEvent = exports.adjustValueType = exports.exchangePlaceholderWithValue = exports.bindingFunc = exports.idBySelector = void 0;
+exports.editArrayButtons = editArrayButtons;
+exports.generateNewObjectStructure = generateNewObjectStructure;
+exports.generateActions = generateActions;
+exports.calcValue = calcValue;
+exports.roundValue = roundValue;
+const telegram_js_1 = require("./telegram.js");
+const global_1 = require("./global");
+const subMenu_js_1 = require("./subMenu.js");
+const sendNav_js_1 = require("./sendNav.js");
+const backMenu_js_1 = require("./backMenu.js");
+const logging_js_1 = require("./logging.js");
+const main_js_1 = require("../main.js");
+const bindingFunc = async (text, userToSend, telegramInstance, one_time_keyboard, resize_keyboard, userListWithChatID, parse_mode) => {
+    let value;
+    try {
+        const substring = (0, global_1.decomposeText)(text, 'binding:', '}').substring;
+        const arrayOfItems = substring.replace('binding:{', '').replace('}', '').split(';');
+        const bindingObject = {
+            values: {},
+        };
+        for (let item of arrayOfItems) {
+            if (!item.includes('?')) {
+                const key = item.split(':')[0];
+                const id = item.split(':')[1];
+                const result = await main_js_1._this.getForeignStateAsync(id);
+                if (result) {
+                    bindingObject.values[key] = result.val?.toString() || '';
+                }
+            }
+            else {
+                Object.keys(bindingObject.values).forEach(function (key) {
+                    item = item.replace(key, bindingObject.values[key]);
+                });
+                value = eval(item);
+            }
+        }
+        await (0, telegram_js_1.sendToTelegram)({
+            user: userToSend,
+            textToSend: value,
+            keyboard: undefined,
+            instance: telegramInstance,
+            resize_keyboard: one_time_keyboard,
+            one_time_keyboard: resize_keyboard,
+            userListWithChatID: userListWithChatID,
+            parse_mode: parse_mode,
+        });
+    }
+    catch (e) {
+        (0, logging_js_1.errorLogger)('Error Binding function: ', e);
+    }
+};
+exports.bindingFunc = bindingFunc;
+function calcValue(textToSend, val) {
+    const { substring } = (0, global_1.decomposeText)(textToSend, '{math:', '}');
+    const mathValue = substring.replace('{math:', '').replace('}', '');
+    try {
+        val = eval(val + mathValue);
+        textToSend = textToSend.replace(substring, '');
+        return { textToSend: textToSend, val: val };
+    }
+    catch (e) {
+        (0, logging_js_1.errorLogger)('Error Eval:', e);
+    }
+}
+function checkValueForOneLine(text) {
+    if (!text.includes('&&')) {
+        return `${text}&&`;
+    }
+    return text;
+}
+function editArrayButtons(val) {
+    const newVal = [];
+    try {
+        val.forEach(element => {
+            let value = '';
+            if (typeof element.value === 'string') {
+                value = checkValueForOneLine(element.value);
+            }
+            let array = [];
+            if (value.indexOf('&&') != -1) {
+                array = value.split('&&');
+            }
+            if (array.length > 1) {
+                array.forEach(function (element, index) {
+                    if (typeof element === 'string') {
+                        let navArray = element.split(',');
+                        navArray = navArray.map(item => item.trim());
+                        array[index] = navArray;
+                    }
+                });
+            }
+            else if (typeof element.value === 'string') {
+                array = element.value.split(',');
+                array.forEach(function (element, index) {
+                    array[index] = [element.trim()];
+                });
+            }
+            newVal.push({ call: element.call, text: element.text, parse_mode: element.parse_mode, nav: array });
+        });
+        return newVal;
+    }
+    catch (err) {
+        (0, logging_js_1.errorLogger)('Error EditArray:', err);
+        return null;
+    }
+}
+const idBySelector = async (selector, text, userToSend, newline, telegramInstance, one_time_keyboard, resize_keyboard, userListWithChatID) => {
+    let text2Send = '';
+    try {
+        if (!selector.includes('functions')) {
+            return;
+        }
+        const functions = selector.replace('functions=', '');
+        let enums = [];
+        const result = await main_js_1._this.getEnumsAsync();
+        if (!result || !result['enum.functions'][`enum.functions.${functions}`]) {
+            return;
+        }
+        enums = result['enum.functions'][`enum.functions.${functions}`].common.members;
+        if (!enums) {
+            return;
+        }
+        const promises = enums.map(async (id) => {
+            const value = await main_js_1._this.getForeignStateAsync(id);
+            if (value && value.val !== undefined && value.val !== null) {
+                let newText = text;
+                let res;
+                if (text.includes('{common.name}')) {
+                    res = await main_js_1._this.getForeignObjectAsync(id);
+                    main_js_1._this.log.debug(`Name ${JSON.stringify(res?.common.name)}`);
+                    if (res && res.common.name) {
+                        newText = newText.replace('{common.name}', res.common.name);
+                    }
+                }
+                if (text.includes('&&')) {
+                    text2Send += newText.replace('&&', value.val);
+                }
+                else if (text.includes('&&')) {
+                    text2Send += newText.replace('&&', value.val);
+                }
+                else {
+                    text2Send += newText;
+                    text2Send += ` ${value.val}`;
+                }
+            }
+            if (newline === 'true') {
+                text2Send += ' \n';
+            }
+            else {
+                text2Send += ' ';
+            }
+            main_js_1._this.log.debug(`text2send ${JSON.stringify(text2Send)}`);
+        });
+        Promise.all(promises)
+            .then(() => {
+            (0, telegram_js_1.sendToTelegram)({
+                user: userToSend,
+                textToSend: text2Send,
+                keyboard: undefined,
+                instance: telegramInstance,
+                resize_keyboard: one_time_keyboard,
+                one_time_keyboard: resize_keyboard,
+                userListWithChatID: userListWithChatID,
+                parse_mode: 'false',
+            }).catch(e => {
+                (0, logging_js_1.errorLogger)('Error SendToTelegram:', e);
+            });
+            main_js_1._this.log.debug(`TextToSend: ${text2Send}`);
+            main_js_1._this.log.debug(`UserToSend: ${userToSend}`);
+        })
+            .catch(e => {
+            (0, logging_js_1.errorLogger)('Error Promise:', e);
+        });
+    }
+    catch (error) {
+        error([
+            { text: 'Error idBySelector:', val: error.message },
+            { text: 'Stack:', val: error.stack },
+        ]);
+    }
+};
+exports.idBySelector = idBySelector;
+function generateNewObjectStructure(val) {
+    try {
+        if (!val) {
+            return null;
+        }
+        const obj = {};
+        val.forEach(function (element) {
+            const call = element.call;
+            obj[call] = {
+                nav: element.nav,
+                text: element.text,
+                parse_mode: element.parse_mode == 'true' || element.parse_mode == 'false' ? element.parse_mode : 'false',
+            };
+        });
+        return obj;
+    }
+    catch (err) {
+        (0, logging_js_1.errorLogger)('Error GenerateNewObjectStructure:', err);
+        return null;
+    }
+}
+function generateActions(action, userObject) {
+    try {
+        const arrayOfEntries = [
+            {
+                objName: 'echarts',
+                name: 'echarts',
+                loop: 'preset',
+                elements: [
+                    { name: 'preset' },
+                    { name: 'echartInstance' },
+                    { name: 'background' },
+                    { name: 'theme' },
+                    { name: 'filename' },
+                ],
+            },
+            {
+                objName: 'loc',
+                name: 'location',
+                loop: 'latitude',
+                elements: [{ name: 'latitude' }, { name: 'longitude' }, { name: 'parse_mode', key: 0 }],
+            },
+            {
+                objName: 'pic',
+                name: 'sendPic',
+                loop: 'IDs',
+                elements: [
+                    { name: 'id', value: 'IDs' },
+                    { name: 'fileName' },
+                    { name: 'delay', value: 'picSendDelay' },
+                ],
+            },
+            {
+                objName: 'get',
+                name: 'getData',
+                loop: 'IDs',
+                elements: [
+                    { name: 'id', value: 'IDs' },
+                    { name: 'text', type: 'text' },
+                    { name: 'newline', value: 'newline_checkbox' },
+                    { name: 'parse_mode', key: 0 },
+                ],
+            },
+            {
+                objName: 'httpRequest',
+                name: 'httpRequest',
+                loop: 'url',
+                elements: [{ name: 'url' }, { name: 'user' }, { name: 'password' }, { name: 'filename' }],
+            },
+        ];
+        const listOfSetStateIds = [];
+        action.set.forEach(function (element, key) {
+            if (key == 0) {
+                userObject[element.trigger[0]] = { switch: [] };
+            }
+            userObject[element.trigger[0]] = { switch: [] };
+            element.IDs.forEach(function (id, index) {
+                listOfSetStateIds.push(id);
+                const toggle = element.switch_checkbox[index] === 'true';
+                let value;
+                if (element.values[index] === 'true' || element.values[index] === 'false') {
+                    value = element.values[index] === 'true';
+                }
+                else {
+                    value = element.values[index];
+                }
+                const newObj = {
+                    id: element.IDs[index],
+                    value: value.toString(),
+                    toggle: toggle,
+                    confirm: element.confirm[index],
+                    returnText: element.returnText[index],
+                    ack: element.ack ? element.ack[index] : 'false',
+                    parse_mode: element.parse_mode ? element.parse_mode[0] : 'false',
+                };
+                if (userObject[element.trigger[0]] && userObject[element.trigger[0]]?.switch) {
+                    userObject[element.trigger[0]].switch.push(newObj);
+                }
+            });
+        });
+        arrayOfEntries.forEach(item => {
+            if (action[item.objName]) {
+                action[item.objName].forEach(function (element, index) {
+                    userObject[element.trigger[0]] = { [item.name]: [] };
+                    if (index == 0) {
+                        userObject[element.trigger[0]] = { [item.name]: [] };
+                    }
+                    element[item.loop].forEach(function (id, key) {
+                        const newObj = {};
+                        item.elements.forEach(elementItem => {
+                            const name = elementItem.name;
+                            const value = elementItem.value ? elementItem.value : elementItem.name;
+                            const newKey = elementItem.key ? elementItem.key : key;
+                            let val;
+                            if (!element[value]) {
+                                val = false;
+                            }
+                            else {
+                                val = element[value][newKey] || 'false';
+                            }
+                            if (elementItem.type == 'text' && typeof val === 'string') {
+                                newObj[name] = val.replace(/&/g, '&');
+                            }
+                            else {
+                                newObj[name] = val;
+                            }
+                        });
+                        if (item.name && typeof item.name === 'string') {
+                            userObject[element.trigger][item?.name].push(newObj);
+                        }
+                    });
+                });
+            }
+        });
+        return { obj: userObject, ids: listOfSetStateIds };
+    }
+    catch (err) {
+        (0, logging_js_1.errorLogger)('Error generateActions:', err);
+    }
+}
+function roundValue(val, textToSend) {
+    try {
+        const floatedNumber = parseFloat(val);
+        const { substring, textWithoutSubstring } = (0, global_1.decomposeText)(textToSend, '{round:', '}');
+        const decimalPlaces = substring.split(':')[1].replace('}', '');
+        const floatedString = floatedNumber.toFixed(parseInt(decimalPlaces));
+        return { val: floatedString, textToSend: textWithoutSubstring };
+    }
+    catch (err) {
+        (0, logging_js_1.errorLogger)('Error roundValue:', err);
+    }
+}
+const exchangePlaceholderWithValue = (textToSend, text) => {
+    let searchString = '';
+    if (textToSend.includes('&&')) {
+        searchString = '&&';
+    }
+    else if (textToSend.includes('&&')) {
+        searchString = '&&';
+    }
+    searchString !== '' && textToSend.toString().indexOf(searchString) != -1
+        ? (textToSend = textToSend.replace(searchString, text.toString()))
+        : (textToSend += ` ${text}`);
+    return textToSend;
+};
+exports.exchangePlaceholderWithValue = exchangePlaceholderWithValue;
+const adjustValueType = (value, valueType) => {
+    if (valueType == 'number') {
+        if (!parseFloat(value)) {
+            main_js_1._this.log.error(`Error: Value is not a number: ${value}`);
+            return false;
+        }
+        return parseFloat(value);
+    }
+    if (valueType == 'boolean') {
+        if (value == 'true') {
+            return true;
+        }
+        main_js_1._this.log.error(`Error: Value is not a boolean: ${value}`);
+        return false;
+    }
+    return value;
+};
+exports.adjustValueType = adjustValueType;
+const checkEvent = async (dataObject, id, state, menuData, userListWithChatID, instanceTelegram, resize_keyboard, one_time_keyboard, usersInGroup) => {
+    const menuArray = [];
+    let ok = false;
+    let calledNav = '';
+    Object.keys(dataObject.action).forEach(menu => {
+        if (dataObject.action[menu] && dataObject.action[menu].events) {
+            dataObject.action[menu].events.forEach(event => {
+                if (event.ID[0] == id && event.ack[0] == state.ack.toString()) {
+                    if ((state.val == true || state.val == 'true') && event.condition == 'true') {
+                        ok = true;
+                        menuArray.push(menu);
+                        calledNav = event.menu[0];
+                    }
+                    else if ((state.val == false || state.val == 'false') && event.condition[0] == 'false') {
+                        ok = true;
+                        menuArray.push(menu);
+                        calledNav = event.menu[0];
+                    }
+                    else if (typeof state.val == 'number' && state.val == parseInt(event.condition[0])) {
+                        ok = true;
+                        menuArray.push(menu);
+                        calledNav = event.menu[0];
+                    }
+                    else if (state.val == event.condition[0]) {
+                        ok = true;
+                        menuArray.push(menu);
+                        calledNav = event.menu[0];
+                    }
+                }
+            });
+        }
+    });
+    if (ok) {
+        if (menuArray.length >= 1) {
+            for (const menu of menuArray) {
+                if (usersInGroup[menu] && menuData.data[menu][calledNav]) {
+                    for (const user of usersInGroup[menu]) {
+                        const part = menuData.data[menu][calledNav];
+                        const menus = Object.keys(menuData.data);
+                        if (part.nav) {
+                            (0, backMenu_js_1.backMenuFunc)(calledNav, part.nav, user);
+                        }
+                        if (part?.nav && part?.nav[0][0].includes('menu:')) {
+                            await (0, subMenu_js_1.callSubMenu)(JSON.stringify(part?.nav[0]), menuData, user, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, part, menuData.data, menus, null, part.nav);
+                        }
+                        else {
+                            await (0, sendNav_js_1.sendNav)(part, user, instanceTelegram, userListWithChatID, resize_keyboard, one_time_keyboard);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return ok;
+};
+exports.checkEvent = checkEvent;
+const getUserToSendFromUserListWithChatID = (userListWithChatID, chatID) => {
+    let userToSend = null;
+    for (const element of userListWithChatID) {
+        if (element.chatID == chatID) {
+            userToSend = element.name;
+            break;
+        }
+    }
+    return userToSend;
+};
+exports.getUserToSendFromUserListWithChatID = getUserToSendFromUserListWithChatID;
+const getMenusWithUserToSend = (menusWithUsers, userToSend) => {
+    const menus = [];
+    for (const key in menusWithUsers) {
+        if (menusWithUsers[key].includes(userToSend)) {
+            menus.push(key);
+        }
+    }
+    return menus;
+};
+exports.getMenusWithUserToSend = getMenusWithUserToSend;

package/build/build/src/app/adapterStartMenuSend.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterStartMenuSend = adapterStartMenuSend;
+const telegram_1 = require("./telegram");
+const backMenu_1 = require("./backMenu");
+const main_1 = require("../main");
+const string_1 = require("../lib/string");
+async function adapterStartMenuSend(listOfMenus, startSides, userActiveCheckbox, menusWithUsers, menuData, userListWithChatID, instanceTelegram, resize_keyboard, one_time_keyboard) {
+    for (const menu of listOfMenus) {
+        const startSide = [startSides[menu]].toString();
+        if (userActiveCheckbox[menu] && startSide != '-' && startSide != '') {
+            main_1._this.log.debug(`Startseite: ${startSide}`);
+            for (const user of menusWithUsers[menu]) {
+                (0, backMenu_1.backMenuFunc)(startSide, menuData.data[menu][startSide].nav, user);
+                main_1._this.log.debug(`User list: ${(0, string_1.jsonString)(userListWithChatID)}`);
+                await (0, telegram_1.sendToTelegram)({
+                    user: user,
+                    textToSend: menuData.data[menu][startSide].text,
+                    keyboard: menuData.data[menu][startSide].nav,
+                    instance: instanceTelegram,
+                    resize_keyboard: resize_keyboard,
+                    one_time_keyboard: one_time_keyboard,
+                    userListWithChatID: userListWithChatID,
+                    parse_mode: menuData.data[menu][startSide].parse_mode,
+                });
+            }
+        }
+        else {
+            if (startSide == '-') {
+                main_1._this.log.debug(`Menu "${menu}" is a Submenu.`);
+                continue;
+            }
+            main_1._this.log.debug(`Menu "${menu}" is inactive.`);
+        }
+    }
+}

package/build/build/src/app/backMenu.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.switchBack = switchBack;
+exports.backMenuFunc = backMenuFunc;
+const logging_1 = require("./logging");
+const utilities_1 = require("../lib/utilities");
+const main_1 = require("../main");
+const string_1 = require("../lib/string");
+const backMenu = {};
+function backMenuFunc(nav, part, userToSend) {
+    if (!part || !JSON.stringify(part).split(`"`)[1].includes('menu:')) {
+        if (backMenu[userToSend] && backMenu[userToSend].list.length === 20) {
+            backMenu[userToSend].list.shift();
+        }
+        else if (!backMenu[userToSend]) {
+            backMenu[userToSend] = { list: [], last: '' };
+        }
+        if (backMenu[userToSend].last !== '') {
+            backMenu[userToSend].list.push(backMenu[userToSend].last);
+        }
+        backMenu[userToSend].last = nav;
+    }
+    main_1._this.log.debug(`BackMenu: ${(0, string_1.jsonString)(backMenu)}`);
+}
+async function switchBack(userToSend, allMenusWithData, menus, lastMenu = false) {
+    try {
+        const list = backMenu[userToSend] && backMenu[userToSend]?.list ? backMenu[userToSend].list : [];
+        let keyboard = { inline_keyboard: [] };
+        let foundedMenu = '';
+        if (list.length != 0) {
+            for (const menu of menus) {
+                if (lastMenu && allMenusWithData[menu]?.[backMenu[userToSend].last]?.nav) {
+                    keyboard = allMenusWithData[menu][backMenu[userToSend].last].nav;
+                    foundedMenu = menu;
+                    break;
+                }
+                else if (allMenusWithData[menu][list[list.length - 1]]?.nav && !lastMenu) {
+                    keyboard = allMenusWithData[menu][list[list.length - 1]].nav;
+                    main_1._this.log.debug('Menu call found');
+                    foundedMenu = menu;
+                    break;
+                }
+                main_1._this.log.debug(`Menu call not found in this Menu: ${menu}`);
+            }
+            if (keyboard && foundedMenu != '') {
+                let parseMode = '';
+                if (!lastMenu) {
+                    let textToSend = allMenusWithData[foundedMenu][backMenu[userToSend].list[backMenu[userToSend].list.length - 1]].text;
+                    if (textToSend) {
+                        textToSend = await (0, utilities_1.checkStatusInfo)(textToSend);
+                    }
+                    parseMode = (allMenusWithData[foundedMenu][backMenu[userToSend].list[backMenu[userToSend].list.length - 1]].parse_mode || 'false');
+                    backMenu[userToSend].last = list.pop();
+                    return { texttosend: textToSend, menuToSend: keyboard, parseMode: parseMode };
+                }
+                parseMode = (allMenusWithData[foundedMenu][backMenu[userToSend].last].parse_mode ||
+                    'false');
+                return {
+                    texttosend: allMenusWithData[foundedMenu][backMenu[userToSend].last].text,
+                    menuToSend: keyboard,
+                    parseMode: parseMode,
+                };
+            }
+        }
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error in switchBack:', e);
+    }
+}

package/build/build/src/app/botAction.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteMessageByBot = void 0;
+const main_1 = require("../main");
+const logging_1 = require("./logging");
+const deleteMessageByBot = (instance, user, userListWithChatID, messageId, chat_id) => {
+    try {
+        if (chat_id) {
+            main_1._this.log.debug(`Delete Message for ${user} ${chat_id} , MessageId: ${messageId}`);
+        }
+        main_1._this.sendTo(instance, {
+            deleteMessage: {
+                options: {
+                    chat_id: chat_id,
+                    message_id: messageId,
+                },
+            },
+        });
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error deleteMessage:', e);
+    }
+};
+exports.deleteMessageByBot = deleteMessageByBot;