iobroker.telegram-menu 2.2.3 → 2.3.0

package/build/main.js

@@ -33,20 +33,23 @@ __export(main_exports, {
 });
 module.exports = __toCommonJS(main_exports);
 var utils = __toESM(require("@iobroker/adapter-core"));
-var import_action = require("./lib/action.js");
-var import_subscribeStates = require("./lib/subscribeStates.js");
-var import_telegram = require("./lib/telegram.js");
-var import_utilities = require("./lib/utilities.js");
-var import_createState = require("./lib/createState.js");
-var import_messageIds = require("./lib/messageIds.js");
-var import_adapterStartMenuSend = require("./lib/adapterStartMenuSend.js");
-var import_processData = require("./lib/processData.js");
-var import_shoppingList = require("./lib/shoppingList.js");
-var import_logging = require("./lib/logging.js");
-var import_connection = require("./lib/connection.js");
-var import_global = require("./lib/global");
+var import_action = require("./app/action.js");
+var import_subscribeStates = require("./app/subscribeStates.js");
+var import_telegram = require("./app/telegram.js");
+var import_createState = require("./app/createState.js");
+var import_messageIds = require("./app/messageIds.js");
+var import_adapterStartMenuSend = require("./app/adapterStartMenuSend.js");
+var import_processData = require("./app/processData.js");
+var import_shoppingList = require("./app/shoppingList.js");
+var import_logging = require("./app/logging.js");
+var import_connection = require("./app/connection.js");
+var import_string = require("./lib/string");
+var import_utils = require("./lib/utils");
+var import_appUtils = require("./lib/appUtils");
+var import_configVariables = require("./app/configVariables");
+var import_setStateIdsToListenTo = require("./app/setStateIdsToListenTo");
 const timeoutKey = "0";
-let subscribeForeignStateIds;
+let adapter;
 class TelegramMenu extends utils.Adapter {
   static instance;
   /**
@@ -61,91 +64,67 @@ class TelegramMenu extends utils.Adapter {
     this.on("unload", this.onUnload.bind(this));
     TelegramMenu.instance = this;
   }
-  static getInstance() {
-    return TelegramMenu.instance;
-  }
   async onReady() {
+    adapter = this;
     await this.setState("info.connection", false, true);
     await (0, import_createState.createState)(this);
-    let instanceTelegram = this.config.instance;
-    if (!instanceTelegram || instanceTelegram.length == 0) {
-      instanceTelegram = "telegram.0";
-    }
-    const telegramID = `${instanceTelegram}.communicate.request`;
-    const botSendMessageID = `${instanceTelegram}.communicate.botSendMessageId`;
-    const requestMessageID = `${instanceTelegram}.communicate.requestMessageId`;
-    const infoConnectionOfTelegram = `${instanceTelegram}.info.connection`;
-    const checkboxes = this.config.checkbox;
-    const one_time_keyboard = checkboxes.oneTiKey;
-    const resize_keyboard = checkboxes.resKey;
-    const checkboxNoEntryFound = checkboxes.checkboxNoValueFound;
-    const sendMenuAfterRestart = checkboxes.sendMenuAfterRestart;
-    let listOfMenus = [];
-    if (this.config.usersInGroup) {
-      listOfMenus = Object.keys(this.config.usersInGroup);
-    }
-    const token = this.config.tokenGrafana;
-    const directoryPicture = this.config.directory;
-    const isUserActiveCheckbox = this.config.userActiveCheckbox;
-    const menusWithUsers = this.config.usersInGroup;
-    const textNoEntryFound = this.config.textNoEntry;
-    const userListWithChatID = this.config.userListWithChatID;
-    const dataObject = this.config.data;
-    const startSides = {};
-    const menuData = {
-      data: {}
-    };
-    Object.keys(menusWithUsers).forEach((element) => {
-      startSides[element] = dataObject.nav[element][0].call;
-    });
-    await this.getForeignObject(infoConnectionOfTelegram, async (err, obj) => {
-      try {
-        if (err || obj == null) {
+    const {
+      requestMessageID,
+      directoryPicture,
+      telegramParams,
+      telegramID,
+      menusWithUsers,
+      infoConnectionOfTelegram,
+      listOfMenus,
+      isUserActiveCheckbox,
+      checkboxNoEntryFound,
+      textNoEntryFound,
+      botSendMessageID,
+      sendMenuAfterRestart,
+      token,
+      dataObject,
+      checkboxes
+    } = (0, import_configVariables.getConfigVariables)(this.config);
+    const { telegramInstance } = telegramParams;
+    const menuData = {};
+    const startSides = (0, import_appUtils.getStartSides)(menusWithUsers, dataObject);
+    try {
+      await this.getForeignObject(infoConnectionOfTelegram, async (err, obj) => {
+        var _a;
+        if (err || !obj) {
           this.log.error(`The State ${infoConnectionOfTelegram} was not found! ${err}`);
           return;
         }
-        const isTelegramActive = await (0, import_connection.checkIsTelegramActive)(infoConnectionOfTelegram);
-        if (!isTelegramActive) {
+        if (!await (0, import_connection.checkIsTelegramActive)(infoConnectionOfTelegram)) {
           return;
         }
         const { nav, action } = dataObject;
         this.log.info("Telegram was found");
         for (const name in nav) {
-          const value = (0, import_action.editArrayButtons)(nav[name], this);
-          const newObjectStructure = (0, import_action.generateNewObjectStructure)(value);
-          if (newObjectStructure) {
-            menuData.data[name] = newObjectStructure;
-          }
-          const generatedActions = (0, import_action.generateActions)(
-            action[name],
-            menuData.data[name]
-          );
+          const splittedNavigation = (0, import_appUtils.splitNavigation)(nav[name]);
+          const newStructure = (0, import_appUtils.getNewStructure)(splittedNavigation);
+          const generatedActions = (0, import_action.generateActions)({ action: action[name], userObject: newStructure });
+          menuData[name] = newStructure;
           if (generatedActions) {
-            menuData.data[name] = generatedActions == null ? void 0 : generatedActions.obj;
-            subscribeForeignStateIds = generatedActions == null ? void 0 : generatedActions.ids;
-          } else {
-            (0, import_logging.debug)([{ text: "No Actions generated!" }]);
-          }
-          if (subscribeForeignStateIds && (subscribeForeignStateIds == null ? void 0 : subscribeForeignStateIds.length) > 0) {
-            await (0, import_subscribeStates._subscribeForeignStatesAsync)(subscribeForeignStateIds);
+            menuData[name] = generatedActions == null ? void 0 : generatedActions.obj;
+            const subscribeForeignStateIds = generatedActions == null ? void 0 : generatedActions.ids;
+            if (subscribeForeignStateIds == null ? void 0 : subscribeForeignStateIds.length) {
+              await (0, import_subscribeStates._subscribeForeignStates)(subscribeForeignStateIds);
+            }
           } else {
-            (0, import_logging.debug)([{ text: "Nothing to Subscribe!" }]);
+            adapter.log.debug("No Actions generated!");
           }
-          if (dataObject.action[name] && dataObject.action[name].events) {
+          if ((_a = dataObject.action[name]) == null ? void 0 : _a.events) {
             for (const event of dataObject.action[name].events) {
-              await (0, import_subscribeStates._subscribeForeignStatesAsync)([event.ID]);
+              await (0, import_subscribeStates._subscribeForeignStates)(event.ID);
             }
           }
-          (0, import_logging.debug)([
-            { text: "Menu: ", val: name },
-            { text: "Array Buttons: ", val: value },
-            { text: "Gen. Actions: ", val: menuData.data[name] }
-          ]);
+          adapter.log.debug(`Menu: ${name}`);
+          adapter.log.debug(`Array Buttons: ${(0, import_string.jsonString)(splittedNavigation)}`);
+          adapter.log.debug(`Gen. Actions: ${(0, import_string.jsonString)(menuData[name])}`);
         }
-        (0, import_logging.debug)([
-          { text: "Checkbox", val: checkboxes },
-          { text: "MenuList", val: listOfMenus }
-        ]);
+        adapter.log.debug(`Checkbox: ${(0, import_string.jsonString)(checkboxes)}`);
+        adapter.log.debug(`MenuList: ${(0, import_string.jsonString)(listOfMenus)}`);
         if (sendMenuAfterRestart) {
           await (0, import_adapterStartMenuSend.adapterStartMenuSend)(
             listOfMenus,
@@ -153,199 +132,141 @@ class TelegramMenu extends utils.Adapter {
             isUserActiveCheckbox,
             menusWithUsers,
             menuData,
-            userListWithChatID,
-            instanceTelegram,
-            resize_keyboard,
-            one_time_keyboard
+            telegramParams
           );
         }
         this.on("stateChange", async (id, state) => {
-          const setStateIdsToListenTo = (0, import_processData.getStateIdsToListenTo)();
-          const isActive = await this.checkInfoConnection(id, infoConnectionOfTelegram);
-          if (!isActive) {
+          var _a2, _b, _c;
+          const setStateIdsToListenTo = (0, import_setStateIdsToListenTo.getStateIdsToListenTo)();
+          const isTelegramInstanceActive = await this.checkInfoConnection(id, infoConnectionOfTelegram);
+          if (!isTelegramInstanceActive) {
             return;
           }
-          const obj2 = await this.getChatIDAndUserToSend(instanceTelegram, userListWithChatID);
-          if (!obj2) {
+          const { userToSend, error } = await this.getChatIDAndUserToSend(telegramParams);
+          if (error) {
             return;
           }
-          const { userToSend } = obj2;
-          if ((0, import_global.isString)(state == null ? void 0 : state.val) && state.val.includes("sList:")) {
-            await (0, import_shoppingList.shoppingListSubscribeStateAndDeleteItem)(
-              state.val,
-              instanceTelegram,
-              userListWithChatID,
-              resize_keyboard,
-              one_time_keyboard
-            );
+          if (this.isAddToShoppingList(id, userToSend)) {
+            await (0, import_shoppingList.deleteMessageAndSendNewShoppingList)(telegramParams, userToSend);
             return;
           }
-          if (this.isAddToShoppingList(id, userToSend)) {
-            await (0, import_shoppingList.deleteMessageAndSendNewShoppingList)(instanceTelegram, userListWithChatID, userToSend);
+          if (!state || !(0, import_utils.isDefined)(state.val)) {
             return;
           }
-          if (state && await (0, import_action.checkEvent)(
-            dataObject,
-            id,
-            state,
-            menuData,
-            userListWithChatID,
-            instanceTelegram,
-            resize_keyboard,
-            one_time_keyboard,
-            menusWithUsers
-          )) {
+          if ((0, import_string.isString)(state.val) && state.val.includes("sList:")) {
+            await (0, import_shoppingList.shoppingListSubscribeStateAndDeleteItem)(state.val, telegramParams);
+            return;
+          }
+          if (await (0, import_action.checkEvent)(dataObject, id, state, menuData, telegramParams, menusWithUsers)) {
             return;
           }
-          if (this.isMessageID(id, botSendMessageID, requestMessageID) && state) {
-            await (0, import_messageIds.saveMessageIds)(state, instanceTelegram);
+          if (this.isMessageID(id, botSendMessageID, requestMessageID)) {
+            await (0, import_messageIds.saveMessageIds)(state, telegramInstance);
           } else if (this.isMenuToSend(state, id, telegramID, userToSend)) {
-            let value = state == null ? void 0 : state.val;
-            if (!value || !userToSend) {
-              return;
-            }
-            value = value.toString();
+            const value = state.val.toString();
             const calledValue = value.slice(value.indexOf("]") + 1, value.length);
-            const menus = (0, import_action.getMenusWithUserToSend)(menusWithUsers, userToSend);
+            const menus = (0, import_appUtils.getListOfMenusIncludingUser)(menusWithUsers, userToSend);
             const dataFound = await (0, import_processData.checkEveryMenuForData)({
               menuData,
               calledValue,
               userToSend,
-              instanceTelegram,
-              resize_keyboard,
-              one_time_keyboard,
-              userListWithChatID,
+              telegramParams,
               menus,
               isUserActiveCheckbox,
               token,
               directoryPicture,
               timeoutKey
             });
-            (0, import_logging.debug)([
-              { text: "Groups with searched User:", val: menus },
-              { text: "Data found:", val: dataFound }
-            ]);
-            if (!dataFound && checkboxNoEntryFound && userToSend) {
-              (0, import_logging.debug)([{ text: "No Entry found" }]);
-              await (0, import_telegram.sendToTelegram)(
+            this.log.debug(`Groups with searched User: ${(0, import_string.jsonString)(menus)}`);
+            if (!dataFound && checkboxNoEntryFound) {
+              adapter.log.debug("No Entry found");
+              await (0, import_telegram.sendToTelegram)({
                 userToSend,
-                textNoEntryFound,
-                void 0,
-                instanceTelegram,
-                resize_keyboard,
-                one_time_keyboard,
-                userListWithChatID,
-                "false"
-              );
+                textToSend: textNoEntryFound,
+                telegramParams
+              });
             }
             return;
           }
-          if (state && setStateIdsToListenTo && setStateIdsToListenTo.find((element) => element.id == id)) {
-            (0, import_logging.debug)([
-              { text: "State, which is listen to was changed:", val: id },
-              { text: "State:", val: state }
-            ]);
-            setStateIdsToListenTo.forEach((element, key) => {
-              var _a, _b;
-              if (element.id == id) {
-                (0, import_logging.debug)([
-                  { text: "Send Value:", val: element },
-                  { text: "Ack:", val: state.ack }
-                ]);
-                if (!(0, import_global.isFalsy)(element.confirm) && !(state == null ? void 0 : state.ack) && element.returnText.includes("{confirmSet:")) {
-                  const substring = (0, import_utilities.decomposeText)(
-                    element.returnText,
-                    "{confirmSet:",
-                    "}"
-                  ).substring.split(":");
-                  (0, import_logging.debug)([{ text: "Substring:", val: substring }]);
+          if (state && (setStateIdsToListenTo == null ? void 0 : setStateIdsToListenTo.find((element) => element.id == id))) {
+            adapter.log.debug(`State, which is listen to was changed: ${id}`);
+            adapter.log.debug(`State: ${(0, import_string.jsonString)(state)}`);
+            for (const el of setStateIdsToListenTo) {
+              const { id: elId, userToSend: userToSend2, confirm, returnText, parse_mode } = el;
+              const key = setStateIdsToListenTo.indexOf(el);
+              if (elId == id) {
+                adapter.log.debug(`Send Value: ${(0, import_string.jsonString)(el)}`);
+                adapter.log.debug(`State: ${(0, import_string.jsonString)(state)}`);
+                if ((0, import_utils.isTruthy)(confirm) && !(state == null ? void 0 : state.ack) && returnText.includes("{confirmSet:")) {
+                  const { substring } = (0, import_string.decomposeText)(returnText, "{confirmSet:", "}");
+                  const splitSubstring = substring.split(":");
+                  adapter.log.debug(`Substring: ${(0, import_string.jsonString)(splitSubstring)}`);
                   let text = "";
-                  if ((0, import_global.isDefined)(state.val)) {
-                    text = substring[2] && substring[2].includes("noValue") ? substring[1] : (0, import_action.exchangePlaceholderWithValue)(substring[1], state.val.toString());
+                  if ((0, import_utils.isDefined)(state.val)) {
+                    text = ((_a2 = splitSubstring[2]) == null ? void 0 : _a2.includes("noValue")) ? splitSubstring[1] : (0, import_appUtils.exchangePlaceholderWithValue)(splitSubstring[1], state.val.toString());
                   }
-                  (0, import_logging.debug)([{ text: "Return-text:", val: text }]);
+                  adapter.log.debug(`Return-text: ${text}`);
                   if (text === "") {
-                    (0, import_logging.error)([{ text: "The return text cannot be empty, please check." }]);
+                    adapter.log.error("The return text cannot be empty, please check.");
                   }
-                  (0, import_telegram.sendToTelegram)(
-                    element.userToSend,
-                    text,
-                    void 0,
-                    instanceTelegram,
-                    resize_keyboard,
-                    one_time_keyboard,
-                    userListWithChatID,
-                    element.parse_mode
-                  ).catch((e) => {
-                    (0, import_logging.error)([
-                      { text: "Error SendToTelegram" },
-                      { val: e.message },
-                      { text: "Error", val: e.stack }
-                    ]);
+                  await (0, import_telegram.sendToTelegram)({
+                    textToSend: text,
+                    parse_mode,
+                    userToSend: userToSend2,
+                    telegramParams
                   });
-                  return;
+                  continue;
                 }
-                (0, import_logging.debug)([
-                  {
-                    text: "Data: ",
-                    val: { confirm: element.confirm, ack: state == null ? void 0 : state.ack, val: state == null ? void 0 : state.val }
-                  }
-                ]);
-                if (!(0, import_global.isFalsy)(element.confirm) && (state == null ? void 0 : state.ack)) {
-                  let textToSend = element.returnText;
+                adapter.log.debug(`Data: ${(0, import_string.jsonString)({ confirm, ack: state == null ? void 0 : state.ack, val: state == null ? void 0 : state.val })}`);
+                if (!(0, import_utils.isFalsy)(confirm) && (state == null ? void 0 : state.ack)) {
+                  let textToSend = returnText;
                   if (textToSend.includes("{confirmSet:")) {
-                    const substring = (0, import_utilities.decomposeText)(textToSend, "{confirmSet:", "}").substring;
-                    textToSend = textToSend.replace(substring, "");
+                    const { textExcludeSubstring } = (0, import_string.decomposeText)(textToSend, "{confirmSet:", "}");
+                    textToSend = textExcludeSubstring;
                   }
                   let value = "";
                   let valueChange = null;
-                  const resultChange = (0, import_utilities.changeValue)(textToSend, ((_a = state.val) == null ? void 0 : _a.toString()) || "");
-                  if (resultChange) {
-                    valueChange = resultChange.val;
-                    textToSend = resultChange.textToSend;
+                  const {
+                    newValue,
+                    textToSend: changedText,
+                    error: error2
+                  } = (0, import_string.getValueToExchange)(adapter, textToSend, (_b = state.val) == null ? void 0 : _b.toString());
+                  if (!error2) {
+                    valueChange = newValue;
+                    textToSend = changedText;
                   }
                   if (textToSend == null ? void 0 : textToSend.toString().includes("{novalue}")) {
                     value = "";
                     textToSend = textToSend.replace("{novalue}", "");
-                  } else if ((0, import_global.isDefined)(state == null ? void 0 : state.val)) {
-                    value = ((_b = state.val) == null ? void 0 : _b.toString()) || "";
+                  } else if ((0, import_utils.isDefined)(state == null ? void 0 : state.val)) {
+                    value = (_c = state.val) == null ? void 0 : _c.toString();
                   }
-                  if (valueChange) {
+                  if ((0, import_utils.isDefined)(valueChange)) {
                     value = valueChange;
                   }
-                  (0, import_logging.debug)([{ text: "Value to send:", val: value }]);
-                  textToSend = (0, import_action.exchangePlaceholderWithValue)(textToSend, value);
-                  (0, import_telegram.sendToTelegram)(
-                    element.userToSend,
+                  adapter.log.debug(`Value to send: ${value}`);
+                  textToSend = (0, import_appUtils.exchangePlaceholderWithValue)(textToSend, value);
+                  await (0, import_telegram.sendToTelegram)({
+                    userToSend: userToSend2,
                     textToSend,
-                    void 0,
-                    instanceTelegram,
-                    resize_keyboard,
-                    one_time_keyboard,
-                    userListWithChatID,
-                    element.parse_mode
-                  ).catch((e) => {
-                    (0, import_logging.error)([
-                      { text: "Error sendToTelegram" },
-                      { val: e.message },
-                      { text: "Error", val: e.stack }
-                    ]);
+                    parse_mode,
+                    telegramParams
                   });
                   setStateIdsToListenTo.splice(key, 1);
                 }
               }
-            });
+            }
           }
         });
-      } catch (e) {
-        (0, import_logging.error)([{ text: "Error onReady" }, { val: e.message }, { text: "Error", val: e.stack }]);
-      }
-    });
+      });
+    } catch (e) {
+      (0, import_logging.errorLogger)("Error onReady", e, adapter);
+    }
     await this.subscribeForeignStatesAsync(botSendMessageID);
     await this.subscribeForeignStatesAsync(requestMessageID);
-    await this.subscribeForeignStatesAsync(`${instanceTelegram}.communicate.requestChatId`);
+    await this.subscribeForeignStatesAsync(`${telegramInstance}.communicate.requestChatId`);
     await this.subscribeForeignStatesAsync(telegramID);
-    await this.subscribeForeignStatesAsync(`${instanceTelegram}.info.connection`);
+    await this.subscribeForeignStatesAsync(`${telegramInstance}.info.connection`);
   }
   isMessageID(id, botSendMessageID, requestMessageID) {
     return id == botSendMessageID || id == requestMessageID;
@@ -354,12 +275,11 @@ class TelegramMenu extends utils.Adapter {
     return !!(id.includes("alexa-shoppinglist") && !id.includes("add_position") && userToSend);
   }
   isMenuToSend(state, id, telegramID, userToSend) {
-    return !!(state && typeof state.val === "string" && state.val != "" && id == telegramID && (state == null ? void 0 : state.ack) && userToSend);
+    return !!(typeof (state == null ? void 0 : state.val) === "string" && state.val != "" && id == telegramID && (state == null ? void 0 : state.ack) && userToSend);
   }
   async checkInfoConnection(id, infoConnectionOfTelegram) {
     if (id === infoConnectionOfTelegram) {
-      const isActive = await (0, import_connection.checkIsTelegramActive)(infoConnectionOfTelegram);
-      if (!isActive) {
+      if (!await (0, import_connection.checkIsTelegramActive)(infoConnectionOfTelegram)) {
         this.log.debug("Telegram is not active");
         return false;
       }
@@ -367,18 +287,19 @@ class TelegramMenu extends utils.Adapter {
     }
     return true;
   }
-  async getChatIDAndUserToSend(instanceTelegram, userListWithChatID) {
-    const chatID = await this.getForeignStateAsync(`${instanceTelegram}.communicate.requestChatId`);
-    if (!(chatID == null ? void 0 : chatID.val)) {
-      (0, import_logging.debug)([{ text: "ChatID not found" }]);
-      return;
+  async getChatIDAndUserToSend(telegramParams) {
+    const { telegramInstance, userListWithChatID } = telegramParams;
+    const chatIDState = await this.getForeignStateAsync(`${telegramInstance}.communicate.requestChatId`);
+    if (!(chatIDState == null ? void 0 : chatIDState.val)) {
+      adapter.log.debug("ChatID not found");
+      return { chatID: "", userToSend: "", error: true, errorMessage: "ChatId not found" };
     }
-    const userToSend = (0, import_action.getUserToSendFromUserListWithChatID)(userListWithChatID, chatID.val.toString());
+    const userToSend = (0, import_action.getUserToSendFromUserListWithChatID)(userListWithChatID, chatIDState.val.toString());
     if (!userToSend) {
       this.log.debug("User to send not found");
-      return;
+      return { chatID: chatIDState.val.toString(), userToSend: "", error: true, errorMessage: "User not found" };
     }
-    return { chatID: chatID.val.toString(), userToSend };
+    return { chatID: chatIDState.val.toString(), userToSend, error: false };
   }
   /**
    * Is called when adapter shuts down - callback has to be called under any circumstances!
@@ -388,12 +309,12 @@ class TelegramMenu extends utils.Adapter {
   onUnload(callback) {
     const timeouts = (0, import_processData.getTimeouts)();
     try {
-      timeouts.forEach((element) => {
-        clearTimeout(element.timeout);
+      timeouts.forEach(({ timeout }) => {
+        adapter.clearTimeout(timeout);
       });
       callback();
     } catch (e) {
-      this.log.error(`Error onUnload  ${e}`);
+      (0, import_logging.errorLogger)(e, "Error onUnload", adapter);
       callback();
     }
   }
@@ -408,11 +329,10 @@ class TelegramMenu extends utils.Adapter {
     }
   }
 }
-let adapter;
 if (require.main !== module) {
-  adapter = (options) => new TelegramMenu(options);
+  module.exports = (options) => new TelegramMenu(options);
 } else {
-  new TelegramMenu();
+  (() => new TelegramMenu())();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {