iobroker.telegram-menu 2.2.4 → 2.3.0

package/build/build/src/app/messageIds.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteMessageIds = deleteMessageIds;
+exports.saveMessageIds = saveMessageIds;
+const main_1 = require("../main");
+const botAction_1 = require("./botAction");
+const logging_1 = require("./logging");
+const global_1 = require("./global");
+const utils_1 = require("../lib/utils");
+let isDeleting = false;
+async function saveMessageIds(state, instanceTelegram) {
+    try {
+        let requestMessageId = {};
+        let requestMessageIdObj = null;
+        if (!isDeleting) {
+            requestMessageIdObj = await main_1._this.getStateAsync('communication.requestIds');
+        }
+        isDeleting = false;
+        const requestUserIdObj = await main_1._this.getForeignStateAsync(`${instanceTelegram}.communicate.requestChatId`);
+        const request = await main_1._this.getForeignStateAsync(`${instanceTelegram}.communicate.request`);
+        if (!(requestUserIdObj && requestUserIdObj.val)) {
+            return;
+        }
+        requestMessageId = requestMessageIdObj?.val ? JSON.parse(requestMessageIdObj?.val.toString()) : {};
+        if (!requestMessageId[requestUserIdObj.val.toString()]) {
+            requestMessageId[requestUserIdObj.val.toString()] = [];
+        }
+        if (!requestMessageId[requestUserIdObj.val.toString()]?.find(message => message.id === state.val)) {
+            requestMessageId[requestUserIdObj.val.toString()].push({
+                id: state.val,
+                time: Date.now(),
+                request: request?.val,
+            });
+        }
+        requestMessageId = removeOldMessageIds(requestMessageId, requestUserIdObj.val.toString());
+        await main_1._this.setState('communication.requestIds', JSON.stringify(requestMessageId), true);
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error saveMessageIds:', e);
+    }
+}
+function removeOldMessageIds(messages, chatID) {
+    messages[chatID] = messages[chatID].filter(message => {
+        return message.time && message.time > Date.now() - 1000 * 60 * 60 * 24 * 2;
+    });
+    return messages;
+}
+const removeMessageFromList = ({ element, chat_id, copyMessageIds, }) => {
+    return copyMessageIds[chat_id].filter(message => message.id !== element.id);
+};
+async function deleteMessageIds(user, userListWithChatID, instanceTelegram, whatShouldDelete) {
+    try {
+        const requestMessageIdObj = await main_1._this.getStateAsync('communication.requestIds');
+        const lastMessageId = await main_1._this.getForeignStateAsync(`${instanceTelegram}.communicate.requestMessageId`);
+        if (!requestMessageIdObj ||
+            typeof requestMessageIdObj.val !== 'string' ||
+            !JSON.parse(requestMessageIdObj.val)) {
+            return;
+        }
+        const chat_id = (0, utils_1.getChatID)(userListWithChatID, user);
+        if (!chat_id) {
+            return;
+        }
+        const messageIds = JSON.parse(requestMessageIdObj.val);
+        if (lastMessageId && lastMessageId.val) {
+            messageIds[chat_id].push({ id: lastMessageId.val.toString() });
+        }
+        isDeleting = true;
+        const copyMessageIds = (0, global_1.deepCopy)(messageIds);
+        messageIds[chat_id].forEach((element, index) => {
+            if (whatShouldDelete === 'all' && element.id) {
+                (0, botAction_1.deleteMessageByBot)(instanceTelegram, user, userListWithChatID, parseInt(element.id?.toString()), chat_id);
+            }
+            if (whatShouldDelete === 'last' && index === messageIds[chat_id].length - 1 && element.id) {
+                (0, botAction_1.deleteMessageByBot)(instanceTelegram, user, userListWithChatID, parseInt(element.id?.toString()), chat_id);
+            }
+            if (!copyMessageIds) {
+                return;
+            }
+            copyMessageIds[chat_id] = removeMessageFromList({ element, chat_id, copyMessageIds });
+        });
+        await main_1._this.setState('communication.requestIds', JSON.stringify(copyMessageIds), true);
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error deleteMessageIds:', e);
+    }
+}

package/build/build/src/app/processData.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStateIdsToListenTo = getStateIdsToListenTo;
+exports.getTimeouts = getTimeouts;
+exports.checkEveryMenuForData = checkEveryMenuForData;
+const main_1 = require("../main");
+const telegram_1 = require("./telegram");
+const sendNav_1 = require("./sendNav");
+const subMenu_1 = require("./subMenu");
+const backMenu_1 = require("./backMenu");
+const setstate_1 = require("./setstate");
+const getstate_1 = require("./getstate");
+const sendpic_1 = require("./sendpic");
+const dynamicValue_1 = require("./dynamicValue");
+const action_1 = require("./action");
+const subscribeStates_1 = require("./subscribeStates");
+const echarts_1 = require("./echarts");
+const httpRequest_1 = require("./httpRequest");
+const logging_1 = require("./logging");
+const string_1 = require("../lib/string");
+let setStateIdsToListenTo = [];
+let timeouts = [];
+async function checkEveryMenuForData(obj) {
+    const { menuData, calledValue, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, menus, isUserActiveCheckbox, token, directoryPicture, timeoutKey, } = obj;
+    for (const menu of menus) {
+        const groupData = menuData.data[menu];
+        main_1._this.log.debug(`Menu: ${menu}`);
+        main_1._this.log.debug(`Nav: ${(0, string_1.jsonString)(menuData.data[menu])}`);
+        if (await processData({
+            menuData,
+            calledValue,
+            userToSend,
+            groupWithUser: menu,
+            instanceTelegram,
+            resize_keyboard: resize_keyboard,
+            one_time_keyboard: one_time_keyboard,
+            userListWithChatID,
+            allMenusWithData: menuData.data,
+            menus,
+            isUserActiveCheckbox,
+            token,
+            directoryPicture,
+            timeoutKey,
+            groupData,
+        })) {
+            main_1._this.log.debug('CalledText found');
+            return true;
+        }
+    }
+    return false;
+}
+async function processData(obj) {
+    const { menuData, calledValue, userToSend, groupWithUser, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, allMenusWithData, menus, isUserActiveCheckbox, token, directoryPicture, timeoutKey, groupData, } = obj;
+    try {
+        let part = {};
+        let call = '';
+        if ((0, dynamicValue_1.getDynamicValue)(userToSend)) {
+            const res = (0, dynamicValue_1.getDynamicValue)(userToSend);
+            let valueToSet;
+            if (res && res.valueType) {
+                valueToSet = (0, action_1.adjustValueType)(calledValue, res.valueType);
+            }
+            else {
+                valueToSet = calledValue;
+            }
+            if (valueToSet && res?.id) {
+                await main_1._this.setForeignStateAsync(res?.id, valueToSet, res?.ack);
+            }
+            else {
+                await (0, telegram_1.sendToTelegram)({
+                    user: userToSend,
+                    textToSend: `You insert a wrong Type of value, please insert type: ${res?.valueType}`,
+                    keyboard: undefined,
+                    instance: instanceTelegram,
+                    resize_keyboard: resize_keyboard,
+                    one_time_keyboard: one_time_keyboard,
+                    userListWithChatID: userListWithChatID,
+                    parse_mode: 'false',
+                });
+            }
+            (0, dynamicValue_1.removeUserFromDynamicValue)(userToSend);
+            const result = await (0, backMenu_1.switchBack)(userToSend, allMenusWithData, menus, true);
+            if (result) {
+                await (0, telegram_1.sendToTelegram)({
+                    user: userToSend,
+                    textToSend: result.texttosend || '',
+                    keyboard: result.menuToSend,
+                    instance: instanceTelegram,
+                    resize_keyboard: resize_keyboard,
+                    one_time_keyboard: one_time_keyboard,
+                    userListWithChatID: userListWithChatID,
+                    parse_mode: result.parseMode,
+                });
+            }
+            else {
+                await (0, sendNav_1.sendNav)(part, userToSend, instanceTelegram, userListWithChatID, resize_keyboard, one_time_keyboard);
+            }
+            return true;
+        }
+        if (calledValue.includes('menu:')) {
+            call = calledValue.split(':')[2];
+        }
+        else {
+            call = calledValue;
+        }
+        part = groupData[call];
+        if (typeof call === 'string' &&
+            groupData &&
+            part &&
+            !calledValue.toString().includes('menu:') &&
+            userToSend &&
+            groupWithUser &&
+            isUserActiveCheckbox[groupWithUser]) {
+            if (part.nav) {
+                main_1._this.log.debug(`Menu to Send: ${part.nav}`);
+                (0, backMenu_1.backMenuFunc)(call, part.nav, userToSend);
+                if (JSON.stringify(part.nav).includes('menu:')) {
+                    main_1._this.log.debug(`Submenu: ${part.nav}`);
+                    const result = await (0, subMenu_1.callSubMenu)(JSON.stringify(part.nav), groupData, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, part, allMenusWithData, menus, setStateIdsToListenTo, part.nav);
+                    if (result && result.setStateIdsToListenTo) {
+                        setStateIdsToListenTo = result.setStateIdsToListenTo;
+                    }
+                    if (result && result.newNav) {
+                        await checkEveryMenuForData({
+                            menuData,
+                            calledValue: result.newNav,
+                            userToSend,
+                            instanceTelegram,
+                            resize_keyboard,
+                            one_time_keyboard,
+                            userListWithChatID,
+                            menus,
+                            isUserActiveCheckbox,
+                            token,
+                            directoryPicture,
+                            timeoutKey,
+                        });
+                    }
+                }
+                else {
+                    await (0, sendNav_1.sendNav)(part, userToSend, instanceTelegram, userListWithChatID, resize_keyboard, one_time_keyboard);
+                }
+                return true;
+            }
+            if (part.switch) {
+                const result = await (0, setstate_1.setState)(part, userToSend, 0, false, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID);
+                if (result) {
+                    setStateIdsToListenTo = result;
+                }
+                if (Array.isArray(setStateIdsToListenTo)) {
+                    await (0, subscribeStates_1._subscribeAndUnSubscribeForeignStatesAsync)({ array: setStateIdsToListenTo });
+                }
+                return true;
+            }
+            if (part.getData) {
+                (0, getstate_1.getState)(part, userToSend, instanceTelegram, one_time_keyboard, resize_keyboard, userListWithChatID);
+                return true;
+            }
+            if (part.sendPic) {
+                const result = (0, sendpic_1.sendPic)(part, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, token, directoryPicture, timeouts, timeoutKey);
+                if (result) {
+                    timeouts = result;
+                }
+                else {
+                    main_1._this.log.debug(`Timeouts not found`);
+                }
+                return true;
+            }
+            if (part.location) {
+                main_1._this.log.debug('Send location');
+                await (0, telegram_1.sendLocationToTelegram)(userToSend, part.location, instanceTelegram, userListWithChatID);
+                return true;
+            }
+            if (part.echarts) {
+                main_1._this.log.debug('Send echars');
+                (0, echarts_1.getChart)(part.echarts, directoryPicture, userToSend, instanceTelegram, userListWithChatID, resize_keyboard, one_time_keyboard);
+                return true;
+            }
+            if (part.httpRequest) {
+                main_1._this.log.debug('Send http request');
+                const result = await (0, httpRequest_1.httpRequest)(part, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, directoryPicture);
+                if (result) {
+                    return true;
+                }
+            }
+        }
+        if ((calledValue.startsWith('menu') || calledValue.startsWith('submenu')) &&
+            menuData.data[groupWithUser][call]) {
+            main_1._this.log.debug('Call Submenu');
+            const result = await (0, subMenu_1.callSubMenu)(calledValue, menuData, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, part, allMenusWithData, menus, setStateIdsToListenTo, part.nav);
+            if (result && result.setStateIdsToListenTo) {
+                setStateIdsToListenTo = result.setStateIdsToListenTo;
+            }
+            return true;
+        }
+        return false;
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error processData:', e);
+    }
+}
+function getStateIdsToListenTo() {
+    return setStateIdsToListenTo;
+}
+function getTimeouts() {
+    return timeouts;
+}

package/build/build/src/app/sendNav.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendNav = sendNav;
+const telegram_1 = require("./telegram");
+const utilities_1 = require("../lib/utilities");
+const main_1 = require("../main");
+const logging_1 = require("./logging");
+async function sendNav(part, userToSend, instanceTelegram, userListWithChatID, resize_keyboard, one_time_keyboard) {
+    try {
+        if (userToSend) {
+            main_1._this.log.debug('Send Nav to Telegram');
+            const nav = part.nav;
+            const text = await (0, utilities_1.checkStatusInfo)(part.text);
+            await (0, telegram_1.sendToTelegram)({
+                user: userToSend,
+                textToSend: text,
+                keyboard: nav,
+                instance: instanceTelegram,
+                resize_keyboard: resize_keyboard,
+                one_time_keyboard: one_time_keyboard,
+                userListWithChatID: userListWithChatID,
+                parse_mode: part.parse_mode || 'false',
+            });
+        }
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error sendNav:', e);
+    }
+}

package/build/build/src/app/sendpic.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendPic = sendPic;
+const telegram_1 = require("./telegram");
+const global_1 = require("./global");
+const child_process_1 = require("child_process");
+const logging_1 = require("./logging");
+const main_1 = require("../main");
+const string_1 = require("../lib/string");
+function sendPic(part, userToSend, instanceTelegram, resize_keyboard, one_time_keyboard, userListWithChatID, token, directoryPicture, timeouts, timeoutKey) {
+    try {
+        part.sendPic?.forEach(element => {
+            const { id, delay, fileName } = element;
+            let path = '';
+            if (id != '-') {
+                const newUrl = (0, string_1.replaceAll)(id, '&', '&');
+                (0, child_process_1.exec)(`curl -H "Autorisation: Bearer ${token.trim()}" "${newUrl}" > ${directoryPicture}${fileName}`, (error, stdout, stderr) => {
+                    if (stdout) {
+                        main_1._this.log.debug(`Stdout: ${stdout}`);
+                    }
+                    if (stderr) {
+                        main_1._this.log.debug(`Stderr: ${stderr}`);
+                    }
+                    if (error) {
+                        (0, logging_1.errorLogger)('Error in exec:', error);
+                        return;
+                    }
+                });
+                main_1._this.log.debug(`Delay Time: ${delay}`);
+                timeoutKey += 1;
+                if (!(0, global_1.checkDirectoryIsOk)(directoryPicture)) {
+                    return;
+                }
+                path = `${directoryPicture}${fileName}`;
+                main_1._this.log.debug(`Path: ${path}`);
+            }
+            else {
+                return;
+            }
+            const timeout = main_1._this.setTimeout(async () => {
+                await (0, telegram_1.sendToTelegram)({
+                    user: userToSend,
+                    textToSend: path,
+                    instance: instanceTelegram,
+                    resize_keyboard: resize_keyboard,
+                    one_time_keyboard: one_time_keyboard,
+                    userListWithChatID: userListWithChatID,
+                    parse_mode: 'false',
+                });
+                let timeoutToClear = [];
+                timeoutToClear = timeouts.filter(item => item.key == timeoutKey);
+                timeoutToClear.forEach(item => {
+                    main_1._this.clearTimeout(item.timeout);
+                });
+                timeouts = timeouts.filter(item => item.key !== timeoutKey);
+                main_1._this.log.debug('Picture sent');
+            }, parseInt(String(element.delay)));
+            if (timeout) {
+                timeouts.push({ key: timeoutKey, timeout: timeout });
+            }
+        });
+        return timeouts;
+    }
+    catch (e) {
+        (0, logging_1.errorLogger)('Error send pic:', e);
+    }
+    return timeouts;
+}

package/build/build/src/app/setstate.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setState = void 0;
+const telegram_1 = require("./telegram");
+const utilities_1 = require("../lib/utilities");
+const dynamicValue_1 = require("./dynamicValue");
+const global_1 = require("./global");
+const main_1 = require("../main");
+const logging_1 = require("./logging");
+const string_1 = require("../lib/string");
+const modifiedValue = (valueFromSubmenu, value) => {
+    if (value && value.includes('{value}')) {
+        return value.replace('{value}', valueFromSubmenu);
+    }
+    return valueFromSubmenu;
+};
+const isDynamicValueToSet = async (value) => {
+    if (typeof value === 'string' && value.includes('{id:')) {
+        const result = (0, global_1.decomposeText)(value, '{id:', '}');
+        const id = result.substring.replace('{id:', '').replace('}', '');
+        const newValue = await main_1._this.getForeignStateAsync(id);
+        if (newValue && newValue.val && typeof newValue.val === 'string') {
+            return value.replace(result.substring, newValue.val);
+        }
+    }
+    return value;
+};
+const setValue = async (id, value, SubmenuValuePriority, valueFromSubmenu, ack) => {
+    try {
+        let valueToSet;
+        SubmenuValuePriority
+            ? (valueToSet = modifiedValue(valueFromSubmenu, value))
+            : (valueToSet = await isDynamicValueToSet(value));
+        await (0, utilities_1.checkTypeOfId)(id, valueToSet).then((val) => {
+            valueToSet = val;
+            main_1._this.log.debug(`Value to Set: ${(0, string_1.jsonString)(valueToSet)}`);
+            if (valueToSet !== undefined && valueToSet !== null) {
+                main_1._this.setForeignState(id, valueToSet, ack);
+            }
+        });
+    }
+    catch (error) {
+        (0, logging_1.errorLogger)('Error setValue', error);
+    }
+};
+const setState = async (part, userToSend, valueFromSubmenu, SubmenuValuePriority, telegramInstance, resize_keyboard, one_time_keyboard, userListWithChatID) => {
+    try {
+        const setStateIds = [];
+        if (!part.switch) {
+            return;
+        }
+        for (const element of part.switch) {
+            let ack = false;
+            let returnText = element.returnText;
+            ack = element?.ack ? element.ack === 'true' : false;
+            if (returnText.includes('{setDynamicValue')) {
+                const { confirmText, id } = await (0, dynamicValue_1.setDynamicValue)(returnText, ack, element.id, userToSend, telegramInstance, one_time_keyboard, resize_keyboard, userListWithChatID, element.parse_mode, element.confirm);
+                if (element.confirm) {
+                    setStateIds.push({
+                        id: id || element.id,
+                        confirm: element.confirm,
+                        returnText: confirmText,
+                        userToSend: userToSend,
+                    });
+                    return setStateIds;
+                }
+            }
+            if (!returnText.includes("{'id':'")) {
+                setStateIds.push({
+                    id: element.id,
+                    confirm: element.confirm,
+                    returnText: returnText,
+                    userToSend: userToSend,
+                    parse_mode: element.parse_mode,
+                });
+            }
+            else {
+                returnText = returnText.replace(/'/g, '"');
+                const textToSend = returnText.slice(0, returnText.indexOf('{')).trim();
+                const returnObj = JSON.parse(returnText.slice(returnText.indexOf('{'), returnText.indexOf('}') + 1));
+                returnObj.text = returnObj.text + returnText.slice(returnText.indexOf('}') + 1);
+                if (textToSend && textToSend !== '') {
+                    await (0, telegram_1.sendToTelegram)({
+                        user: userToSend,
+                        textToSend: textToSend,
+                        keyboard: undefined,
+                        instance: telegramInstance,
+                        resize_keyboard: one_time_keyboard,
+                        one_time_keyboard: resize_keyboard,
+                        userListWithChatID: userListWithChatID,
+                        parse_mode: element.parse_mode,
+                    });
+                }
+                setStateIds.push({
+                    id: returnObj.id,
+                    confirm: true,
+                    returnText: returnObj.text,
+                    userToSend: userToSend,
+                });
+            }
+            if (element.toggle) {
+                main_1._this
+                    .getForeignStateAsync(element.id)
+                    .then(val => {
+                    if (val) {
+                        main_1._this.setForeignStateAsync(element.id, !val.val, ack).catch((e) => {
+                            (0, logging_1.errorLogger)('Error setForeignStateAsync:', e);
+                        });
+                    }
+                })
+                    .catch((e) => {
+                    (0, logging_1.errorLogger)('Error getForeignStateAsync:', e);
+                });
+            }
+            else {
+                await setValue(element.id, element.value, SubmenuValuePriority, valueFromSubmenu, ack);
+            }
+        }
+        return setStateIds;
+    }
+    catch (error) {
+        (0, logging_1.errorLogger)('Error Switch', error);
+    }
+};
+exports.setState = setState;

package/build/build/src/app/shoppingList.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shoppingListSubscribeStateAndDeleteItem = shoppingListSubscribeStateAndDeleteItem;
+exports.deleteMessageAndSendNewShoppingList = deleteMessageAndSendNewShoppingList;
+const messageIds_js_1 = require("./messageIds.js");
+const jsonTable_js_1 = require("./jsonTable.js");
+const telegram_js_1 = require("./telegram.js");
+const subscribeStates_js_1 = require("./subscribeStates.js");
+const logging_js_1 = require("./logging.js");
+const main_js_1 = require("../main.js");
+const string_1 = require("../lib/string");
+const objData = {};
+let isSubscribed = false;
+async function shoppingListSubscribeStateAndDeleteItem(val, instanceTelegram, userListWithChatID, resize_keyboard, one_time_keyboard) {
+    try {
+        let array, user, idList, instance, idItem, res;
+        if (val != null) {
+            array = val.split(':');
+            user = array[0].replace('[', '').replace(']sList', '');
+            idList = array[1];
+            instance = array[2];
+            idItem = array[3];
+            res = await main_js_1._this.getForeignObjectAsync(`alexa2.${instance}.Lists.SHOPPING_LIST.items.${idItem}`);
+            if (res) {
+                objData[user] = { idList: idList };
+                main_js_1._this.log.debug(`Alexa-shoppinglist: ${idList}`);
+                if (!isSubscribed) {
+                    await (0, subscribeStates_js_1._subscribeAndUnSubscribeForeignStatesAsync)({ id: `alexa-shoppinglist.${idList}` });
+                    isSubscribed = true;
+                }
+                await main_js_1._this.setForeignStateAsync(`alexa2.${instance}.Lists.SHOPPING_LIST.items.${idItem}.#delete`, true, false);
+                return;
+            }
+            await (0, telegram_js_1.sendToTelegram)({
+                user: user,
+                textToSend: 'Cannot delete the Item',
+                keyboard: undefined,
+                instance: instanceTelegram,
+                resize_keyboard: resize_keyboard,
+                one_time_keyboard: one_time_keyboard,
+                userListWithChatID: userListWithChatID,
+                parse_mode: 'true',
+            });
+            main_js_1._this.log.debug('Cannot delete the Item');
+            return;
+        }
+    }
+    catch (e) {
+        (0, logging_js_1.errorLogger)('Error shoppingList:', e);
+    }
+}
+async function deleteMessageAndSendNewShoppingList(instanceTelegram, userListWithChatID, userToSend) {
+    try {
+        const user = userToSend;
+        const idList = objData[user].idList;
+        await (0, subscribeStates_js_1._subscribeAndUnSubscribeForeignStatesAsync)({ id: `alexa-shoppinglist.${idList}` });
+        await (0, messageIds_js_1.deleteMessageIds)(user, userListWithChatID, instanceTelegram, 'last');
+        const result = await main_js_1._this.getForeignStateAsync(`alexa-shoppinglist.${idList}`);
+        if (result && result.val) {
+            main_js_1._this.log.debug(`Result from Shoppinglist: ${(0, string_1.jsonString)(result)}`);
+            const newId = `alexa-shoppinglist.${idList}`;
+            const resultJson = (0, jsonTable_js_1.createKeyboardFromJson)(result.val, null, newId, user);
+            if (resultJson && resultJson.text && resultJson.keyboard) {
+                (0, telegram_js_1.sendToTelegramSubmenu)(user, resultJson.text, resultJson.keyboard, instanceTelegram, userListWithChatID, 'true');
+            }
+        }
+    }
+    catch (e) {
+        (0, logging_js_1.errorLogger)('Error deleteMessageAndSendNewShoppingList:', e);
+    }
+}